public DbCommand CreateCommand(DatabaseProvider database, CreateSqlState state)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
IDataParameter[] idataParameters = null;
string sql = this.commandText;
DataParameter[] dps = state.GetDataParameters();
int length = dps.Length;
if (length > 0)
{
idataParameters = new IDataParameter[length];
for (int i = 0; i < length; i++)
{
DataParameter dp = dps[i];
IDataParameter idataParameter = dp.ConvertDbParameter(database, CommandType.Text);
idataParameters[i] = idataParameter;
}
}
DbCommand command = database.CreateCommand(sql);
command.CommandType = this.commandType;
if (idataParameters != null)
{
foreach (IDataParameter param in idataParameters)
{
command.Parameters.Add(param);
}
}
return(command);
}
public static string CreateKey(DataTableEntityMapping mapping, CreateSqlState state)
{
state.TryGetAliasTableName(mapping, out var aliasName);
var type = mapping.ObjectType;
var name = aliasName == null ? type.FullName : string.Concat(type.FullName, "_", aliasName);
return(name);
}
public string CreateSqlString(CommandFactory factory, CreateSqlState state)
{
StringBuilder sb = new StringBuilder();
CommandData command = factory.CreateAggregateTableCommand(_model.EntityMapping, _model.GetSelector(), Model.GetGroupBy(), _query, _having, null, null, state);
string aliasName = _aliasTableName;// ?? factory.CreateDataTableMappingSql(_model.EntityMapping, state);
sb.Append(factory.CreateAliasQuerySql(command.CommandText, aliasName));
return(sb.ToString());
}
public string CreateSqlString(CommandFactory factory, CreateSqlState state)
{
StringBuilder sb = new StringBuilder();
CommandData command = factory.CreateSelectCommand(_model.EntityMapping, _model.CreateSelector(), _query, _order, _distinct, null, state);
string aliasName = _aliasTableName;// ?? factory.CreateDataTableMappingSql(_model.EntityMapping, state);
sb.Append(factory.CreateAliasQuerySql(command.CommandText, aliasName));
return(sb.ToString());
}
public string CreateSqlString(CommandFactory factory, CreateSqlState state)
{
var sb = new StringBuilder();
var command = factory.CreateSelectCommand(Model.EntityMapping, Model.CreateSelector(), Query, Order, Distinct, null, state);
var aliasName = AliasTableName;// ?? factory.CreateDataTableMappingSql(_model.EntityMapping, state);
sb.Append(factory.CreateAliasQuerySql(command.CommandText, aliasName));
return(sb.ToString());
}
public virtual QueryCommand SelectInsert(DataContext context, DataTableEntityMapping insertMapping, DataEntityMapping selectMapping, QueryExpression query, OrderExpression order)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateSelectInsertCommand(insertMapping, selectMapping, query, order, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public virtual QueryCommand SelectInsertWithJoinTable(DataContext context, InsertSelector selector, List <IJoinModel> models, QueryExpression query, OrderExpression order, bool distinct)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateSelectInsertCommand(selector, models, query, order, distinct, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public virtual QueryCommand QueryUpdate(DataContext context, DataTableEntityMapping mapping, MassUpdator updator, QueryExpression query)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateMassUpdateCommand(mapping, updator, query, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public virtual QueryCommand BatchDelete(DataContext context, DataTableEntityMapping mapping, IList datas)
{
CreateSqlState state = new CreateSqlState(context, false);
CommandData commandData = _factory.CreateBatchDeleteCommand(mapping, datas, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public virtual QueryCommand SelectById(DataContext context, DataTableEntityMapping mapping, object id)
{
CreateSqlState state = new CreateSqlState(context, false);
CommandData commandData = _factory.CreateSelectByIdCommand(mapping, id, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public virtual QueryCommand DeleteByKey(DataContext context, DataTableEntityMapping mapping, object[] keys)
{
CreateSqlState state = new CreateSqlState(context, false);
CommandData commandData = _factory.CreateDeleteKeyCommand(mapping, keys, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public virtual QueryCommand QuerySingleField(DataContext context, DataFieldInfo fieldInfo, QueryExpression query, OrderExpression order, bool distinct, Region region)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateSelectSingleFieldCommand(fieldInfo, query, order, distinct, region, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
InnerPage = commandData.InnerPage
};
return(queryCommand);
}
public virtual QueryCommand Aggregate(DataContext context, DataFieldInfo field, AggregateType aggregateType, QueryExpression query, bool distinct)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateAggregateFunctionCommand(field, aggregateType, query, distinct, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
InnerPage = commandData.InnerPage
};
return(queryCommand);
}
public virtual QueryCommand Insert(DataContext context, DataTableEntityMapping mapping, object data, bool refresh, bool updateIdentity)
{
CreateSqlState state = new CreateSqlState(context, false);
CommandData commandData = _factory.CreateBaseInsertCommand(mapping, data, refresh, updateIdentity, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
IdentitySql = commandData.IdentitySql
};
return(queryCommand);
}
public virtual QueryCommand AggregateJoinTableCount(DataContext context, List <IJoinModel> models, QueryExpression query)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateAggregateJoinCountCommand(models, query, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
InnerPage = commandData.InnerPage
};
return(queryCommand);
}
public virtual QueryCommand TruncateTable(DataContext context, DataTableEntityMapping mapping)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateTruncateTableCommand(mapping, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
InnerPage = commandData.InnerPage
};
return(queryCommand);
}
public virtual QueryCommand Exists(DataContext context, DataEntityMapping mapping, QueryExpression query)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateExistsCommand(mapping, query, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
InnerPage = commandData.InnerPage
};
return(queryCommand);
}
public string CreateGroupByString(CommandFactory factory, bool isFullName, CreateSqlState state)
{
var list = new string[groupList.Count];
var index = 0;
foreach (var fieldInfo in groupList)
{
list[index] = fieldInfo.CreateGroupBySqlString(factory, isFullName, state);
index++;
}
var data = string.Join(",", list);
return(data);
}
public string CreateGroupByString(CommandFactory factory, bool isFullName, CreateSqlState state)
{
string[] list = new string[this.groupList.Count];
int index = 0;
foreach (AggregateDataFieldInfo fieldInfo in this.groupList)
{
list[index] = fieldInfo.CreateGroupBySqlString(factory, isFullName, state);
index++;
}
string data = string.Join(",", list);
return(data);
}
public virtual QueryCommand SelectInsertWithAggregate(DataContext context, InsertSelector selector, AggregateModel model, QueryExpression query, QueryExpression having, OrderExpression order)
{
CreateSqlState state = new CreateSqlState(context);
AggregateSelector aselector = model.GetSelector();
AggregateGroupBy groupBy = model.GetGroupBy();
CommandData commandData = _factory.CreateSelectInsertCommand(selector, model.EntityMapping, aselector, groupBy, query, having, order, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public virtual QueryCommand SelectInsert(DataContext context, InsertSelector selector, DataEntityMapping mapping, QueryExpression query, OrderExpression order, bool distinct)
{
RelationMap relationMap = mapping.GetRelationMap();
CommandData commandData;
CreateSqlState state = new CreateSqlState(context);
if (mapping.HasJoinRelateModel)
{
QueryExpression subQuery = null;
QueryExpression mainQuery = null;
OrderExpression subOrder = null;
OrderExpression mainOrder = null;
if (query != null)
{
if (query.MutliQuery)
{
mainQuery = query;
}
else
{
subQuery = query;
}
}
if (order != null)
{
if (order.MutliOrder)
{
mainOrder = order;
}
else
{
subOrder = order;
}
}
List <IJoinModel> models = relationMap.CreateJoinModels(subQuery, subOrder);
commandData = _factory.CreateSelectInsertCommand(selector, models, mainQuery, mainOrder, distinct, state);
}
else
{
commandData = _factory.CreateSelectInsertCommand(selector, mapping, query, order, distinct, state);
}
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public string CreateSelectString(CommandFactory factory, bool isFullName, CreateSqlState state)
{
string[] list = new string[this.selectList.Count];
int index = 0;
foreach (AggregateDataFieldInfo fieldInfo in this.selectList)
{
state.SetAliasData(fieldInfo.FieldInfo, factory.CreateDataFieldSql(fieldInfo.AggregateName));
list[index] = fieldInfo.CreateAliasDataFieldSql(factory, false, state);
index++;
}
string data = string.Join(",", list);
return(data);
}
public string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state)
{
string [] setList = new string[dict.Count];
int index = 0;
foreach (KeyValuePair <DataFieldInfo, DataFieldInfo> kvs in dict)
{
string left = kvs.Key.CreateSqlString(factory, isFullName, state);
string right = kvs.Value.CreateSqlString(factory, isFullName, state);
setList [index] = string.Format("{0}={1}", left, right);
index++;
}
string sql = string.Join(",", setList);
return(sql);
}
//public CommandCache(string command)
//{
// _command = command; ;
//}
//private string _command;
//public string Command {
// get {
// return _command;
// }
//}
public static string CreateKey(DataTableEntityMapping mapping, CreateSqlState state)
{
string name;
state.TryGetAliasTableName(mapping, out string aliasName);
var type = mapping.ObjectType;
if (aliasName == null)
{
name = type.FullName;
}
else
{
name = string.Concat(type.FullName, "_", aliasName);
}
return(name);
}
public virtual QueryCommand BatchUpdate(DataContext context, DataTableEntityMapping mapping, IList datas, bool refresh)
{
CreateSqlState state = new CreateSqlState(context, false);
CommandData commandData = _factory.CreateBatchUpdateCommand(mapping, datas, refresh, state);
if (commandData == null)
{
return(null);
}
DbCommand command = commandData.CreateCommand(this, state);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
public string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state)
{
var setList = new Tuple <string, string> [dict.Count];
var index = 0;
foreach (var kvs in dict)
{
var left = kvs.Key.CreateSqlString(factory, isFullName, state);
var right = kvs.Value.CreateSqlString(factory, isFullName, state);
setList[index] = new Tuple <string, string>(left, right);
index++;
}
var sql = factory.CreateUpdateAssign(setList);
return(sql);
}
public string CreateSqlString(CommandFactory factory, CreateSqlState state)
{
var sb = new StringBuilder();
if (Query != null || Order != null || Distinct)
{
var command = factory.CreateSelectCommand(Mapping, AllSelector.Value, Query, Order, Distinct, null, state);
var aliasName = AliasTableName;// ?? factory.CreateDataTableMappingSql(_mapping, state);
sb.Append(factory.CreateAliasQuerySql(command.CommandText, aliasName));
}
else
{
sb.Append(AliasTableName != null
? factory.CreateAliasTableSql(factory.CreateDataTableMappingSql(Mapping, state), AliasTableName)
: factory.CreateDataTableMappingSql(Mapping, state));
}
return(sb.ToString());
}
public virtual QueryCommand QueryDynamicAggregate(DataContext context, AggregateModel model, QueryExpression query, QueryExpression having, OrderExpression order, Region region)
{
CreateSqlState state = new CreateSqlState(context);
AggregateSelector selector = model.GetSelector();
AggregateGroupBy groupBy = model.GetGroupBy();
CommandData commandData = _factory.CreateAggregateTableCommand(model.EntityMapping, selector, groupBy, query, having, order, region, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryState queryState = new QueryState();
queryState.SetSelector(selector);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
InnerPage = commandData.InnerPage,
State = queryState
};
return(queryCommand);
}
public virtual QueryCommand InsertIdentiy(DataContext context, DataTableEntityMapping mapping)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = null;
if (mapping.IdentityField != null)
{
commandData = _factory.CreateIdentityCommand(mapping, state);
DbCommand command = commandData.CreateCommand(this);
QueryCommand queryCommand = new QueryCommand()
{
Command = command
};
return(queryCommand);
}
else
{
return(null);
}
}
public string CreateSelectString(CommandFactory factory, bool isFullName, CreateSqlState state)
{
string [] selectList = new string [this.infoDict.Count];
int index = 0;
foreach (DataFieldInfo fieldInfo in this.infoDict.Values)
{
IAliasDataFieldInfo aliasInfo = fieldInfo as IAliasDataFieldInfo;
if (!Object.Equals(aliasInfo, null))
{
selectList [index] = aliasInfo.CreateAliasDataFieldSql(factory, true, state);
}
else
{
selectList [index] = fieldInfo.CreateSqlString(factory, true, state);
}
index++;
}
string customSelect = string.Join(",", selectList);
return(customSelect);
}
