/// <summary> /// Query and return data list /// </summary> /// <typeparam name="T">Data type.</typeparam> /// <param name="region">Query region</param> /// <param name="cancellationToken">CancellationToken.</param> /// <returns>Data list</returns> private async Task <List <T> > QueryListAsync <T>(Region region, CancellationToken cancellationToken = default(CancellationToken)) { List <T> list = await _context.QueryDataDefineListAsync <T>(DataEntityMapping.GetEntityMapping(typeof(T)), _level, _command, region, null, null, cancellationToken); Callback(); return(list); }
/// <summary> /// Query and return first data /// </summary> /// <typeparam name="T">Data type.</typeparam> /// <param name="cancellationToken">CancellationToken.</param> /// <returns>First data</returns> public async Task <T> QueryFirstAsync <T>(CancellationToken cancellationToken = default(CancellationToken)) { T target = await _context.QueryDataDefineSingleAsync <T>(DataEntityMapping.GetEntityMapping(typeof(T)), _level, _command, 0, null, null, cancellationToken); Callback(); return(target); }
/// <summary> /// Query and return first data /// </summary> /// <typeparam name="T">Data type.</typeparam> /// <returns>First data</returns> public T QueryFirst <T>() { T target = _context.QueryDataDefineSingle <T>(DataEntityMapping.GetEntityMapping(typeof(T)), _level, _command, 0, null, null); Callback(); return(target); }
/// <summary> /// Query and return data enumerable /// </summary> /// <typeparam name="T">Data type.</typeparam> /// <param name="region">Data region</param> /// <returns>Data enumerable</returns> private IEnumerable <T> Query <T>(Region region) { IEnumerable <T> enumable = _context.QueryDataDefineReader <T>(DataEntityMapping.GetEntityMapping(typeof(T)), _level, _command, region, null, null); Callback(); return(enumable); }
/// <summary> /// 统计行数 /// </summary> /// <param name="mapping">数据映射表</param> /// <param name="query">查询表达式</param> /// <param name="level"></param> /// <returns>查询行数</returns> internal object AggregateCount(DataEntityMapping mapping, QueryExpression query, SafeLevel level) { using (IDbCommand command = _dataBase.Factory.CreateAggregateCountCommand(mapping, query)) { return(ExecuteScalar(command, level)); } }
public SingleParameterLambdaState(ParameterExpression parameter) { _singleEntityName = parameter.Name; var entityMapping = DataEntityMapping.GetEntityMapping(parameter.Type); _singleEntityMap = entityMapping.GetRelationMap(); }
public override int Delete() { var mapping = DataEntityMapping.GetTableMapping(typeof(T)); var queryCommand = _context.Database.QueryDelete(_context, mapping, _query); return(_context.ExecuteNonQuery(queryCommand.Command, _level)); }
public override async Task <int> InsertAsync <K>(CancellationToken cancellationToken = default) { var insertMapping = DataEntityMapping.GetTableMapping(typeof(K)); var queryCommand = _context.Database.SelectInsert(_context, insertMapping, _mapping, _query, _order); return(await _context.ExecuteNonQueryAsync(queryCommand.Command, _level, cancellationToken)); }
public virtual string GetHavingString(DataEntityMapping mapping, AggregateHavingExpression having, out DataParameter[] parameters, Dictionary <string, AggregateFunction> aggregateFunctionDictionary) { string havingString = null; parameters = null; if (having != null) { if (!having.IgnoreConsistency && !mapping.Equals(having.TableMapping)) { throw new LightDataException(RE.DataMappingIsNotMatchAggregationExpression); } havingString = string.Format("having {0}", having.CreateSqlString(this, out parameters, new GetAliasHandler(delegate(object obj) { string alias = null; if (obj is AggregateFunction) { foreach (KeyValuePair <string, AggregateFunction> kv in aggregateFunctionDictionary) { if (Object.ReferenceEquals(obj, kv.Value)) { alias = kv.Key; break; } } } else { throw new LightDataException(RE.UnknowOrderType); } return(alias); }))); } return(havingString); }
public LightMathFunctionDataFieldInfo(DataEntityMapping mapping, MathFunction function, params object[] argsObjects) : base(mapping) { if (argsObjects == null || argsObjects.Length == 0) { throw new ArgumentNullException(nameof(argsObjects)); } if (function == MathFunction.Atan2 || function == MathFunction.Max || function == MathFunction.Min || function == MathFunction.Pow) { if (argsObjects.Length != 2) { throw new ArgumentNullException(nameof(argsObjects)); } } if (function == MathFunction.Log || function == MathFunction.Round) { if (argsObjects.Length > 2) { throw new ArgumentNullException(nameof(argsObjects)); } } _function = function; _argsObjects = argsObjects; }
public override async Task <int> DeleteAsync(CancellationToken cancellationToken = default) { var mapping = DataEntityMapping.GetTableMapping(typeof(T)); var queryCommand = _context.Database.QueryDelete(_context, mapping, _query); return(await _context.ExecuteNonQueryAsync(queryCommand.Command, _level, cancellationToken)); }
public LightBinaryQueryExpression(DataEntityMapping mapping, QueryPredicate predicate, object left, object right) : base(mapping) { _predicate = predicate; _left = left; _right = right; }
public override string CreateRandomOrderBySql(DataEntityMapping mapping) { Random rnd = new Random(unchecked ((int)DateTime.Now.Ticks)); int intRandomNumber = rnd.Next() * -1; string field = ""; foreach (DataFieldMapping df in mapping.GetFieldMappings()) { if (df.ObjectType == typeof(int)) { field = CreateDataFieldSql(df.Name); break; } } if (string.IsNullOrEmpty(field)) { foreach (DataFieldMapping df in mapping.GetFieldMappings()) { if (df.ObjectType == typeof(string)) { field = string.Format("len({0})", CreateDataFieldSql(df.Name)); break; } } } if (string.IsNullOrEmpty(field)) { throw new LightDataException(RE.TypfOfDataFieldIsNotString); } return(string.Format("rnd({0}*{1})", intRandomNumber, field)); }
public LightMathCalculateDataFieldInfo(DataEntityMapping mapping, MathOperator opera, object left, object right) : base(mapping) { _opera = opera; _left = left; _right = right; }
/// <summary> /// Query and return data list /// </summary> /// <typeparam name="T">Data type.</typeparam> /// <param name="region">Query region</param> /// <returns>Data list</returns> private List <T> QueryList <T>(Region region) { List <T> list = _context.QueryDataDefineList <T>(DataEntityMapping.GetEntityMapping(typeof(T)), _level, _command, region, null, null); Callback(); return(list); }
protected override IDbCommand CreateSelectBaseCommand(DataEntityMapping mapping, string customSelect, QueryExpression query, OrderExpression order, Region region) { if (region == null) { return(base.CreateSelectBaseCommand(mapping, customSelect, query, order, null)); } StringBuilder sql = new StringBuilder(); DataParameter[] parameters; string queryString = GetQueryString(mapping, query, out parameters); string orderString = GetOrderString(mapping, order); bool distinct = false; if (customSelect.StartsWith("distinct ", StringComparison.OrdinalIgnoreCase)) { distinct = true; customSelect = customSelect.Substring(9); } if (region.Start == 0) { sql.AppendFormat("select {3}top {2} {0} from {1}", customSelect, CreateDataTableSql(mapping.TableName), region.Size, distinct ? "distinct " : string.Empty); if (!string.IsNullOrEmpty(queryString)) { sql.AppendFormat(" {0}", queryString); } if (!string.IsNullOrEmpty(orderString)) { sql.AppendFormat(" {0}", orderString); } } else { // example // select * // from ( // select row_number()over(order by __tc__)__rn__,* // from (select top 开始位置+10 0 __tc__,* from Student where Age>18 order by Age)t // )tt // where __rn__>开始位置 // StringBuilder innerSQL = new StringBuilder(); string tempCount = CreateCustomFiledName(); string tempRowNumber = CreateCustomFiledName(); innerSQL.AppendFormat("select {4}top {2} {0},0 {3} from {1}", customSelect, CreateDataTableSql(mapping.TableName), region.Start + region.Size, tempCount, distinct ? "distinct " : string.Empty); if (!string.IsNullOrEmpty(queryString)) { innerSQL.AppendFormat(" {0}", queryString); } if (!string.IsNullOrEmpty(orderString)) { innerSQL.AppendFormat(" {0}", orderString); } sql.AppendFormat("select {1} from (select a.*,row_number()over(order by {3}) {4} from ({0})a )b where {4}>{2}", innerSQL, customSelect, region.Start, tempCount, tempRowNumber); } IDbCommand command = BuildCommand(sql.ToString(), parameters); return(command); }
public override int Insert <K>() { var insertMapping = DataEntityMapping.GetTableMapping(typeof(K)); var queryCommand = _context.Database.SelectInsert(_context, insertMapping, _mapping, _query, _order); return(_context.ExecuteNonQuery(queryCommand.Command, _level)); }
public AggregateLambdaState(ParameterExpression parameter, AggregateModel model) { aggregateModel = model; aggregateName = parameter.Name; aggregateType = parameter.Type; entityMapping = model.EntityMapping; }
public override string GetOrderString(DataEntityMapping mapping, OrderExpression order, out DataParameter[] parameters, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary) { string orderString = null; 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, new GetAliasHandler(delegate(object obj) { return(null); }))); } return(orderString); }
public LightStringFunctionDataFieldInfo(DataEntityMapping mapping, StringFunction function, object callObject, params object [] argsObjects) : base(mapping) { if (callObject == null) { throw new ArgumentNullException(nameof(callObject)); } if (function == StringFunction.ToLower || function == StringFunction.ToUpper || function == StringFunction.Trim) { if (argsObjects != null && argsObjects.Length > 0) { throw new ArgumentNullException(nameof(argsObjects)); } } if (function == StringFunction.Replace) { if (argsObjects == null || argsObjects.Length != 2) { throw new ArgumentNullException(nameof(argsObjects)); } } if (function == StringFunction.Substring || function == StringFunction.IndexOf) { if (argsObjects == null || argsObjects.Length > 2) { throw new ArgumentNullException(nameof(argsObjects)); } } _function = function; _callObject = callObject; _argsObjects = argsObjects; }
/// <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)); } }
internal BasicFieldInfo(DataEntityMapping tableMapping) { if (tableMapping == null) { throw new ArgumentNullException(nameof(tableMapping)); } TableMapping = tableMapping; }
public LightSubQueryDataFieldInfo(DataEntityMapping mapping, DataFieldInfo field, DataFieldInfo selectField, QueryCollectionPredicate predicate, QueryExpression expression) : base(mapping) { _field = field; _selectField = selectField; _predicate = predicate; _expression = expression; }
public RelateParameterLambdaState(ParameterExpression parameter, LambdaState state) { var entityMapping = DataEntityMapping.GetEntityMapping(parameter.Type); _singleEntityName = parameter.Name; _singleEntityMap = entityMapping.GetRelationMap(); _state = state; }
public bool Equals(DataEntityMapping mapping) { if (mapping == null) { return(false); } return(ObjectType == mapping.ObjectType); }
public SingleParameterLambdaState(ParameterExpression parameter) { this.singleEntityName = parameter.Name; Type type = parameter.Type; DataEntityMapping entityMapping = DataEntityMapping.GetEntityMapping(type); this.singleEntityMap = entityMapping.GetRelationMap(); }
public LightStringMatchDataFieldInfo(DataEntityMapping mapping, bool starts, bool ends, object left, object right) : base(mapping) { _starts = starts; _ends = ends; _left = left; _right = right; }
public override async Task <int> UpdateAsync(Expression <Func <T, T> > expression, CancellationToken cancellationToken = default) { var mapping = DataEntityMapping.GetTableMapping(typeof(T)); var updator = LambdaExpressionExtend.CreateMassUpdateExpression(expression); var queryCommand = _context.Database.QueryUpdate(_context, mapping, updator, _query); return(await _context.ExecuteNonQueryAsync(queryCommand.Command, _level, cancellationToken)); }
public override int Update(Expression <Func <T, T> > expression) { var mapping = DataEntityMapping.GetTableMapping(typeof(T)); var updator = LambdaExpressionExtend.CreateMassUpdateExpression(expression); var queryCommand = _context.Database.QueryUpdate(_context, mapping, updator, _query); return(_context.ExecuteNonQuery(queryCommand.Command, _level)); }
public void SetTableMapping(DataEntityMapping mapping) { if (mapping == null) { throw new ArgumentNullException(nameof(mapping)); } TableMapping = mapping; }