public virtual string GetOrderString(DataEntityMapping mapping, OrderExpression order)
{
string orderString = null;
DataParameter[] parameters = null;
if (order != null)
{
if (order.IgnoreConsistency)
{
RandomOrderExpression random = order as RandomOrderExpression;
if (random != null)
{
random.SetTableMapping(mapping);
}
}
if (!order.IgnoreConsistency && !mapping.Equals(order.TableMapping))
{
throw new LightDataException(RE.DataMappingIsNotMatchOrderExpression);
}
orderString = string.Format("order by {0}", order.CreateSqlString(this, out parameters));
}
return(orderString);
}
public AggregateJoinModel(AggregateModel model, string aliasTableName, JoinConnect connect, QueryExpression query, QueryExpression having, OrderExpression order, JoinSetting setting)
{
this._model = model;
this._connect = connect;
this._query = query;
this._having = having;
this._order = order;
this._aliasTableName = aliasTableName;
this._joinMapping = model.OutputMapping;
if ((setting & JoinSetting.NoDataSetEntityNull) == JoinSetting.NoDataSetEntityNull)
{
_noDataSetEntityNull = true;
}
}
/// <summary>
/// 获取查询单个数据
/// </summary>
/// <param name="mapping">数据对象映射表</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="index">数据索引</param>
/// <param name="level">安全级别</param>
/// <returns>数据对象</returns>
internal object SelectSingle(DataEntityMapping mapping, QueryExpression query, OrderExpression order, int index, SafeLevel level)
{
object target = null;
Region region = new Region(index, 1);
using (IDbCommand command = _dataBase.Factory.CreateSelectCommand(mapping, query, order, IsInnerPager ? region : null))
{
//target = LExecuteReaderSingle(mapping, command, index, level);
foreach (object obj in QueryDataReader(mapping, command, region, level))
{
target = obj;
}
}
return(target);
}
/// <summary>
/// 动态统计数据到数据表中
/// </summary>
/// <param name="mapping">数据映射</param>
/// <param name="dataFieldInfoDictionary">统计字段信息</param>
/// <param name="aggregateFunctionDictionary">统计方法信息</param>
/// <param name="query">查询表达式</param>
/// <param name="having">统计查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="level">安全级别</param>
/// <returns>数据表</returns>
internal DataTable QueryDynamicAggregateTable(DataEntityMapping mapping, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary, QueryExpression query, AggregateHavingExpression having, OrderExpression order, SafeLevel level)
{
using (IDbCommand command = _dataBase.Factory.CreateDynamicAggregateCommand(mapping, dataFieldInfoDictionary, aggregateFunctionDictionary, query, having, order))
{
return(QueryDataTable(command, null, level));
}
}
/// <summary>
/// 查询单列数据
/// </summary>
/// <param name="fieldInfo">字段信息</param>
/// <param name="outputType">输出类型</param>
/// <param name="isNullable">是否可空</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="region">查询范围</param>
/// <param name="distinct">是否排除重复</param>
/// <param name="level">安全级别</param>
/// <returns>单列数据枚举</returns>
internal IEnumerable QueryColumeEnumerable(DataFieldInfo fieldInfo, Type outputType, bool isNullable, QueryExpression query, OrderExpression order, Region region, bool distinct, SafeLevel level)
{
IDbCommand command = _dataBase.Factory.CreateSelectSingleFieldCommand(fieldInfo, query, order, distinct, null);
DataDefine define = TransferDataDefine(outputType, null, isNullable);
return(QueryDataReader(define, command, region, level));
}
/// <summary>
/// 生成数据查询枚举
/// </summary>
/// <param name="mapping">数据映射</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="region">查询范围</param>
/// <param name="level">安全级别</param>
/// <returns>数据枚举</returns>
internal IEnumerable QueryDataEnumerable(DataEntityMapping mapping, QueryExpression query, OrderExpression order, Region region, SafeLevel level)
{
IDbCommand command = _dataBase.Factory.CreateSelectCommand(mapping, query, order, IsInnerPager ? region : null);
return(QueryDataReader(mapping, command, !IsInnerPager ? region : null, level));
}
public virtual IDbCommand CreateDynamicAggregateCommand(DataEntityMapping mapping, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary, QueryExpression query, AggregateHavingExpression having, OrderExpression order)
{
if (dataFieldInfoDictionary == null || dataFieldInfoDictionary.Count == 0)
{
throw new LightDataException(RE.DynamicAggregateFieldIsNotExists);
}
StringBuilder sql = new StringBuilder();
StringBuilder select = new StringBuilder();
StringBuilder groupby = new StringBuilder();
List <DataParameter> parameterlist = new List <DataParameter> ();
bool flat = false;
foreach (KeyValuePair <string, DataFieldInfo> kv in dataFieldInfoDictionary)
{
if (!mapping.Equals(kv.Value.TableMapping))
{
throw new LightDataException(RE.DataMappingIsNotMatchAggregateField);
}
string groupbyField = kv.Value.CreateDataFieldSql(this);
string aliasName = CreateDataFieldSql(kv.Key);
string selectField = string.Format("{0} as {1}", groupbyField, aliasName);
if (!flat)
{
flat = true;
}
else
{
selectField = "," + selectField;
groupbyField = "," + groupbyField;
}
select.Append(selectField);
groupby.Append(groupbyField);
}
foreach (KeyValuePair <string, AggregateFunction> kv in aggregateFunctionDictionary)
{
if (kv.Value.TableMapping != null && !mapping.Equals(kv.Value.TableMapping))
{
throw new LightDataException(RE.DataMappingIsNotMatchAggregateField);
}
DataParameter[] aggparameters = null;
string aggField = kv.Value.CreateSqlString(this, out aggparameters);
string aliasName = CreateDataFieldSql(kv.Key);
string selectField = string.Format(",{0} as {1}", aggField, aliasName);
select.Append(selectField);
parameterlist.AddRange(aggparameters);
}
sql.AppendFormat("select {0} from {1}", select, CreateDataTableSql(mapping.TableName));
DataParameter[] queryparameters = null;
string queryString = GetQueryString(mapping, query, out queryparameters);
DataParameter[] havingparameters = null;
string havingString = GetHavingString(mapping, having, out havingparameters, aggregateFunctionDictionary);
DataParameter[] orderbyparameters = null;
string orderString = GetOrderString(mapping, order, out orderbyparameters, dataFieldInfoDictionary, aggregateFunctionDictionary);
if (!string.IsNullOrEmpty(queryString))
{
sql.AppendFormat(" {0}", queryString);
parameterlist.AddRange(queryparameters);
}
sql.AppendFormat(" group by {0}", groupby);
if (!string.IsNullOrEmpty(havingString))
{
sql.AppendFormat(" {0}", havingString);
parameterlist.AddRange(havingparameters);
}
if (!string.IsNullOrEmpty(orderString))
{
sql.AppendFormat(" {0}", orderString);
parameterlist.AddRange(orderbyparameters);
}
IDbCommand command = BuildCommand(sql.ToString(), parameterlist.ToArray());
return(command);
}
public virtual IDbCommand CreateSelectSingleFieldCommand(DataFieldInfo fieldinfo, QueryExpression query, OrderExpression order, bool distinct, Region region)
{
if (region != null && !_canInnerPage)
{
throw new LightDataException(RE.DataBaseNotSupportInnerPage);
}
DataFieldMapping fieldMapping = fieldinfo.DataField;
if (fieldMapping is PrimitiveFieldMapping || fieldMapping is EnumFieldMapping || fieldMapping is CustomFieldMapping)
{
DataEntityMapping mapping = fieldMapping.EntityMapping;
string select = fieldinfo.CreateDataFieldSql(this);
if (distinct)
{
select = "distinct " + select;
}
return(CreateSelectBaseCommand(mapping, select, query, order, region));
}
else
{
throw new LightDataException(RE.OnlyPrimitiveFieldCanSelectSingle);
}
}
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 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 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 QueryJoinData(DataContext context, DataMapping mapping, ISelector selector, List <IJoinModel> models, QueryExpression query, OrderExpression order, bool distinct, Region region)
{
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateSelectJoinTableCommand(selector, models, query, order, distinct, region, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryState queryState = new QueryState();
foreach (IJoinModel model in models)
{
if (model.NoDataSetEntityNull)
{
queryState.SetNoDataSetNull(model.AliasTableName);
}
}
queryState.SetSelector(selector);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
InnerPage = commandData.InnerPage,
State = queryState
};
return(queryCommand);
}
public virtual QueryCommand QueryEntityData(DataContext context, DataEntityMapping mapping, ISelector selector, QueryExpression query, OrderExpression order, bool distinct, Region region)
{
RelationMap relationMap = mapping.GetRelationMap();
if (selector == null)
{
selector = relationMap.GetDefaultSelector();
}
CreateSqlState state = new CreateSqlState(context);
CommandData commandData = _factory.CreateSelectDataCommand(mapping, relationMap, selector, query, order, distinct, region, state);
DbCommand command = commandData.CreateCommand(this, state);
QueryState queryState = new QueryState();
queryState.SetRelationMap(relationMap);
queryState.SetSelector(selector);
QueryCommand queryCommand = new QueryCommand()
{
Command = command,
InnerPage = commandData.InnerPage,
State = queryState
};
return(queryCommand);
}
public LightSelectField(DataContext context, LambdaExpression expression, QueryExpression query, OrderExpression order, bool distinct, Region region, SafeLevel level)
: base(context, expression)
{
_query = query;
_order = order;
_distinct = distinct;
_region = region;
_level = level;
}
protected LightSelectJoin(DataContext context, LambdaExpression expression, List <IJoinModel> models, List <IMap> maps, QueryExpression query, OrderExpression order, bool distinct, Region region, SafeLevel level)
: base(context, expression, models, maps)
{
_query = query;
_order = order;
_distinct = distinct;
_region = region;
_level = level;
}
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);
}
/// <summary>
/// 创建查询命令
/// </summary>
/// <param name="mapping">数据表映射</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="region">查询范围,如非空则生成内分页语句</param>
/// <returns>查询命令对象</returns>
public virtual IDbCommand CreateSelectCommand(DataEntityMapping mapping, QueryExpression query, OrderExpression order, Region region)
{
if (region != null && !_canInnerPage)
{
throw new LightDataException(RE.DataBaseNotSupportInnerPage);
}
string select = GetSelectString(mapping);
return(this.CreateSelectBaseCommand(mapping, select, query, order, region));
}
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);
}
/// <summary>
/// 创建自定查询内容的命令
/// </summary>
/// <param name="mapping">数据表映射</param>
/// <param name="customSelect">查询输出的内容</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="region">查询范围</param>
/// <returns></returns>
protected virtual IDbCommand CreateSelectBaseCommand(DataEntityMapping mapping, string customSelect, QueryExpression query, OrderExpression order, Region region) //, bool distinct)
{
StringBuilder sql = new StringBuilder();
DataParameter[] parameters;
string queryString = GetQueryString(mapping, query, out parameters);
string orderString = GetOrderString(mapping, order);
sql.AppendFormat("select {0} from {1}", customSelect, CreateDataTableSql(mapping.TableName)); //, distinct ? "distinct " : string.Empty);
if (!string.IsNullOrEmpty(queryString))
{
sql.AppendFormat(" {0}", queryString);
}
if (!string.IsNullOrEmpty(orderString))
{
sql.AppendFormat(" {0}", orderString);
}
IDbCommand command = BuildCommand(sql.ToString(), parameters);
return(command);
}
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 EntityJoinModel(DataEntityMapping mapping, string aliasTableName, JoinConnect connect, QueryExpression query, OrderExpression order, JoinSetting setting)
{
this._mapping = mapping;
//this._selector = AllSelector.Value;
this._connect = connect;
this._query = query;
this._order = order;
this._aliasTableName = aliasTableName;
this._joinMapping = mapping;
if ((setting & JoinSetting.QueryDistinct) == JoinSetting.QueryDistinct)
{
_distinct = true;
}
if ((setting & JoinSetting.NoDataSetEntityNull) == JoinSetting.NoDataSetEntityNull)
{
_noDataSetEntityNull = true;
}
}
/// <summary>
/// 读取关联数据
/// </summary>
/// <param name="keyName">关联字段属性名称</param>
/// <param name="extendQuery">扩展查询</param>
/// <param name="extendOrder">扩展排序</param>
/// <param name="cacheData">是否缓存数据</param>
/// <returns>关联数据</returns>
protected object LoadRelationData(string keyName, QueryExpression extendQuery, OrderExpression extendOrder, bool cacheData)
{
if (Context == null)
{
return(null);
}
if (!cacheData)
{
return(LoadRelationData(keyName, extendQuery, extendOrder));
}
if (!TempRelationDatas.ContainsKey(keyName))
{
lock (synobj2) {
if (!TempRelationDatas.ContainsKey(keyName))
{
TempRelationDatas [keyName] = LoadRelationData(keyName, extendQuery, extendOrder);
}
}
}
return(TempRelationDatas [keyName]);
}
/// <summary>
/// 生成数据查询枚举
/// </summary>
/// <param name="mapping">数据映射</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="region">查询范围</param>
/// <param name="level">安全级别</param>
/// <returns>数据集合</returns>
internal IList QueryDataList(DataEntityMapping mapping, QueryExpression query, OrderExpression order, Region region, SafeLevel level)
{
using (IDbCommand command = _dataBase.Factory.CreateSelectCommand(mapping, query, order, IsInnerPager ? region : null))
{
IList items = CreateList(mapping.ObjectType);
IEnumerable ie = QueryDataReader(mapping, command, !IsInnerPager ? region : null, level);
foreach (object obj in ie)
{
items.Add(obj);
}
return(items);
}
}
/// <summary>
/// 读取关联数据
/// </summary>
/// <param name="keyName">关联字段属性名称</param>
/// <param name="extendOrder">扩展排序</param>
/// <returns>关联数据</returns>
protected object LoadRelationData(string keyName, OrderExpression extendOrder)
{
return(LoadRelationData(keyName, null, extendOrder, true));
}
/// <summary>
/// 查询单列数据
/// </summary>
/// <param name="fieldInfo">字段信息</param>
/// <param name="outputType">输出类型</param>
/// <param name="isNullable">是否可空</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="region">查询范围</param>
/// <param name="distinct">是否排除重复</param>
/// <param name="level">安全级别</param>
/// <returns>数据集合</returns>
internal IList QueryColumeList(DataFieldInfo fieldInfo, Type outputType, bool isNullable, QueryExpression query, OrderExpression order, Region region, bool distinct, SafeLevel level)
{
using (IDbCommand command = _dataBase.Factory.CreateSelectSingleFieldCommand(fieldInfo, query, order, distinct, null))
{
DataDefine define = TransferDataDefine(outputType, null, isNullable);
IList items = CreateList(define.ObjectType);
IEnumerable ie = QueryDataReader(define, command, region, level);
if (define.IsNullable)
{
MethodInfo addMethod = items.GetType().GetMethod("Add");
foreach (object obj in ie)
{
if (Object.Equals(obj, null))
{
addMethod.Invoke(items, new object[] { null });
}
else
{
items.Add(obj);
}
}
}
else
{
foreach (object obj in ie)
{
items.Add(obj);
}
}
return(items);
}
}
/// <summary>
/// 读取关联数据
/// </summary>
/// <param name="keyName">关联字段属性名称</param>
/// <param name="extendQuery">扩展查询</param>
/// <param name="extendOrder">扩展排序</param>
/// <returns>关联数据</returns>
private object LoadRelationData(string keyName, QueryExpression extendQuery, OrderExpression extendOrder)
{
DataEntityMapping selfMapping = DataMapping.GetEntityMapping(this.GetType());
RelationFieldMapping relationMapping = selfMapping.FindRelateionMapping(keyName);
QueryExpression expression = null;
foreach (RelationFieldMapping.RelationKeyValue rt in relationMapping.GetRelationKeyValues())
{
DataFieldInfo info = new DataFieldInfo(relationMapping.RelateTableMapping.ObjectType, rt.RelateField.Name);
object objkey = rt.MasterField.Handler.Get(this);
if (Object.Equals(objkey, null))
{
expression &= info.IsNull();
}
else
{
expression &= info == objkey;
}
}
if (extendQuery != null)
{
expression = QueryExpression.And(expression, extendQuery);
}
//判断与关联表的关联关系
if (relationMapping.Kind == RelationFieldMapping.RelationKind.OneToOne)
{
//一对一关系,直接查询单个对象
object obj = this.Context.SelectSingle(relationMapping.RelateTableMapping, expression, extendOrder, 0, SafeLevel.None);
DataEntity de = obj as DataEntity;
if (de == null)
{
return(obj);
}
if (relationMapping.RelateRelationMapping != null) //判断是否相互关联
{
if (relationMapping.RelateRelationMapping.Kind == RelationFieldMapping.RelationKind.OneToOne)
{
de.TempRelationDatas.Add(relationMapping.RelateRelationMapping.RelationName, this);
}
}
return(de);
}
else
{
IList list = this.Context.QueryDataList(relationMapping.RelateTableMapping, expression, extendOrder, null, SafeLevel.Default) as IList;
//if (list.Count == 0) return list;
if (relationMapping.RelateRelationMapping != null && relationMapping.RelateRelationMapping.MasterTableMapping.IsDataEntity)
{
if (relationMapping.RelateRelationMapping.Kind == RelationFieldMapping.RelationKind.OneToOne)
{
foreach (object obj in list)
{
DataEntity de = obj as DataEntity;
de.TempRelationDatas.Add(relationMapping.RelateRelationMapping.RelationName, this);
}
}
}
if (relationMapping.ResultDataKind == RelationFieldMapping.DataKind.IList)
{
return(list);
}
else
{
Array array = Array.CreateInstance(relationMapping.RelateTableMapping.ObjectType, list.Count);
list.CopyTo(array, 0);
return(array);
}
}
}
/// <summary>
/// 动态统计数据到数据集合中
/// </summary>
/// <param name="mapping">数据映射</param>
/// <param name="amapping">统计结果类型</param>
/// <param name="dataFieldInfoDictionary">统计字段信息</param>
/// <param name="aggregateFunctionDictionary">统计方法信息</param>
/// <param name="query">查询表达式</param>
/// <param name="having">统计查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="level">安全级别</param>
/// <returns>数据集合</returns>
internal IList QueryDynamicAggregateList(DataEntityMapping mapping, AggregateTableMapping amapping, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary, QueryExpression query, AggregateHavingExpression having, OrderExpression order, SafeLevel level)
{
if (amapping.RelateType != null && amapping.RelateType != mapping.ObjectType)
{
throw new LightDataException(string.Format(RE.AggregateTypeIsNotSpecifyType, amapping.RelateType.FullName));
}
using (IDbCommand command = _dataBase.Factory.CreateDynamicAggregateCommand(mapping, dataFieldInfoDictionary, aggregateFunctionDictionary, query, having, order))
{
IList items = CreateList(amapping.ObjectType);
IEnumerable ie = QueryDataReader(amapping, command, null, level);
foreach (object obj in ie)
{
items.Add(obj);
}
return(items);
}
}
public LightSelectJoin(DataContext context, Expression <Func <T, T1, K> > expression, List <IJoinModel> models, List <IMap> maps, QueryExpression query, OrderExpression order, bool distinct, Region region, SafeLevel level)
: base(context, expression, models, maps, query, order, distinct, region, level)
{
}
protected override IDbCommand CreateSelectBaseCommand(DataEntityMapping mapping, string customSelect, QueryExpression query, OrderExpression order, Region region) //, bool distinct)
{
IDbCommand command = base.CreateSelectBaseCommand(mapping, customSelect, query, order, region);
if (region != null)
{
if (region.Start == 0)
{
command.CommandText = string.Format("{0} limit {1}", command.CommandText, region.Size);
}
else
{
command.CommandText = string.Format("{0} limit {1},{2}", command.CommandText, region.Start, region.Size);
}
}
return(command);
}
public AggregateJoinModel(AggregateModel model, string aliasTableName, JoinConnect connect, QueryExpression query, QueryExpression having, OrderExpression order, JoinSetting setting)
{
Model = model;
Connect = connect;
Query = query;
Having = having;
Order = order;
AliasTableName = aliasTableName;
JoinMapping = model.OutputDataMapping;
if ((setting & JoinSetting.NoDataSetEntityNull) == JoinSetting.NoDataSetEntityNull)
{
NoDataSetEntityNull = true;
}
}
