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; } }