public override IAggregate <K> HavingWithOr(Expression <Func <K, bool> > expression) { var queryExpression = LambdaExpressionExtend.ResolveLambdaHavingExpression(expression, Model); _having = QueryExpression.Or(_having, queryExpression); return(this); }
public override IQuery <T> WhereWithOr(Expression <Func <T, bool> > expression) { var queryExpression = LambdaExpressionExtend.ResolveLambdaQueryExpression(expression); _query = QueryExpression.Or(_query, queryExpression); return(this); }
public override IQuery <T> OrderByDescendingConcat <TKey>(Expression <Func <T, TKey> > expression) { var orderExpression = LambdaExpressionExtend.ResolveLambdaOrderByExpression(expression, OrderType.DESC); _order = OrderExpression.Concat(_order, orderExpression); return(this); }
public override IQuery <T> OrderBy <TKey>(Expression <Func <T, TKey> > expression) { var orderExpression = LambdaExpressionExtend.ResolveLambdaOrderByExpression(expression, OrderType.ASC); _order = orderExpression; return(this); }
public override async Task <int> SelectInsertAsync <K>(Expression <Func <T, K> > expression, CancellationToken cancellationToken = default) { var selector = LambdaExpressionExtend.CreateInsertSelector(expression); var queryCommand = _context.Database.SelectInsert(_context, selector, _mapping, _query, _order, _distinct); return(await _context.ExecuteNonQueryAsync(queryCommand.Command, _level, cancellationToken)); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { var sql = state.GetDataSql(this, isFullName); if (sql != null) { return(sql); } object obj = _baseFieldInfo.CreateSqlString(factory, isFullName, state); var values = (IEnumerable)LambdaExpressionExtend.ConvertLambdaObject(_collection); var list = new List <string>(); foreach (var item in values) { list.Add(state.AddDataParameter(factory, _baseFieldInfo.ToParameter(item.AdjustValue()))); } if (list.Count > 0) { sql = factory.CreateCollectionParamsQuerySql(obj, _isNot ? QueryCollectionPredicate.NotIn : QueryCollectionPredicate.In, list); } else { var value = _isNot; sql = factory.CreateBooleanConstantSql(value); } state.SetDataSql(this, isFullName, sql); return(sql); }
public override int SelectInsert <K>(Expression <Func <T, K> > expression) { var selector = LambdaExpressionExtend.CreateInsertSelector(expression); var queryCommand = _context.Database.SelectInsert(_context, selector, _mapping, _query, _order, _distinct); return(_context.ExecuteNonQuery(queryCommand.Command, _level)); }
public async override Task <int> SelectInsertAsync <P>(Expression <Func <K, P> > expression, CancellationToken cancellationToken = default(CancellationToken)) { InsertSelector selector = LambdaExpressionExtend.CreateAggregateInsertSelector(expression, Model); QueryCommand queryCommand = _context.Database.SelectInsertWithAggregate(_context, selector, Model, _query, _having, _order); return(await _context.ExecuteNonQueryAsync(queryCommand.Command, _level, cancellationToken)); }
public override int SelectInsert <P>(Expression <Func <K, P> > expression) { InsertSelector selector = LambdaExpressionExtend.CreateAggregateInsertSelector(expression, Model); QueryCommand queryCommand = _context.Database.SelectInsertWithAggregate(_context, selector, Model, _query, _having, _order); return(_context.ExecuteNonQuery(queryCommand.Command, _level)); }
public override IAggregate <K> OrderByDescendingConcat <TKey>(Expression <Func <K, TKey> > expression) { var orderExpression = LambdaExpressionExtend.ResolveLambdaAggregateOrderByExpression(expression, OrderType.DESC, Model); _order = OrderExpression.Concat(_order, orderExpression); return(this); }
public override IAggregate <K> OrderBy <TKey>(Expression <Func <K, TKey> > expression) { var orderExpression = LambdaExpressionExtend.ResolveLambdaAggregateOrderByExpression(expression, OrderType.ASC, Model); _order = orderExpression; return(this); }
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 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)); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { var value = LambdaExpressionExtend.ConvertLambdaObject(_value); var ret = Convert.ToBoolean(value); if (_not) { ret = !ret; } return(factory.CreateBooleanConstantSql(ret)); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { string sql = state.GetDataSql(this, false); if (sql != null) { return(sql); } object value = LambdaExpressionExtend.ConvertLambdaObject(_value); sql = state.AddDataParameter(factory, value); state.SetDataSql(this, false, sql); return(sql); }
public override async Task <K> AggregateFieldAsync <K>(Expression <Func <T, K> > expression, CancellationToken cancellationToken = default) { var model = LambdaExpressionExtend.CreateAggregateModel(expression); model.OnlyAggregate = true; var region = new Region(0, 1); var queryCommand = _context.Database.QueryDynamicAggregate(_context, model, _query, null, _order, region); var target = await _context.QueryDataDefineSingleAsync <K>(model.OutputDataMapping, _level, queryCommand.Command, queryCommand.InnerPage? 0 : region.Start, queryCommand.State, null, cancellationToken); if (target == null) { var obj = model.OutputDataMapping.InitialData(); target = (K)obj; } return(target); }
public override K AggregateField <K>(Expression <Func <T, K> > expression) { AggregateModel model = LambdaExpressionExtend.CreateAggregateModel(expression); model.OnlyAggregate = true; Region region = new Region(0, 1); //target = _context.QueryDynamicAggregateSingle<K>(model, _query, null, _order, region, _level, null); QueryCommand queryCommand = _context.Database.QueryDynamicAggregate(_context, model, _query, null, _order, region); K target = _context.QueryDataDefineSingle <K>(model.OutputMapping, _level, queryCommand.Command, queryCommand.InnerPage ? 0 : region.Start, queryCommand.State, null); if (target == null) { object obj = model.OutputMapping.InitialData(); target = (K)obj; } return(target); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { var sql = state.GetDataSql(this, isFullName); if (sql != null) { return(sql); } var query = _query.CreateSqlString(factory, isFullName, state); object ifTrue; object ifFalse; var ifTrueInfo = _ifTrue as DataFieldInfo; var ifFalseInfo = _ifFalse as DataFieldInfo; if (!Equals(ifTrueInfo, null) && !Equals(ifFalseInfo, null)) { ifTrue = ifTrueInfo.CreateSqlString(factory, isFullName, state); ifFalse = ifFalseInfo.CreateSqlString(factory, isFullName, state); } else if (!Equals(ifTrueInfo, null)) { ifTrue = ifTrueInfo.CreateSqlString(factory, isFullName, state); var ifFalseObject = LambdaExpressionExtend.ConvertLambdaObject(_ifFalse).AdjustValue(); ifFalse = state.AddDataParameter(factory, ifFalseObject); } else if (!Equals(ifFalseInfo, null)) { ifFalse = ifFalseInfo.CreateSqlString(factory, isFullName, state); var ifTrueObject = LambdaExpressionExtend.ConvertLambdaObject(_ifTrue).AdjustValue(); ifTrue = state.AddDataParameter(factory, ifTrueObject); } else { var ifTrueObject = LambdaExpressionExtend.ConvertLambdaObject(_ifTrue).AdjustValue(); var ifFalseObject = LambdaExpressionExtend.ConvertLambdaObject(_ifFalse).AdjustValue(); ifTrue = state.AddDataParameter(factory, ifTrueObject); ifFalse = state.AddDataParameter(factory, ifFalseObject); } sql = factory.CreateConditionSql(query, ifTrue, ifFalse); state.SetDataSql(this, isFullName, sql); return(sql); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { string sql = state.GetDataSql(this, isFullName); if (sql != null) { return(sql); } object left; object right; DataFieldInfo leftInfo = _left as DataFieldInfo; DataFieldInfo rightInfo = _right as DataFieldInfo; if (!Object.Equals(leftInfo, null) && !Object.Equals(rightInfo, null)) { left = leftInfo.CreateSqlString(factory, isFullName, state); right = rightInfo.CreateSqlString(factory, isFullName, state); } else if (!Object.Equals(leftInfo, null)) { left = leftInfo.CreateSqlString(factory, isFullName, state); object rightObject = LambdaExpressionExtend.ConvertLambdaObject(_right); right = state.AddDataParameter(factory, rightObject); } else if (!Object.Equals(rightInfo, null)) { right = rightInfo.CreateSqlString(factory, isFullName, state); object leftObject = LambdaExpressionExtend.ConvertLambdaObject(_left); left = state.AddDataParameter(factory, leftObject); } else { throw new LightDataException(SR.DataFieldContentError); } sql = factory.CreateLikeMatchQuerySql(left, right, _starts, _ends, _isNot); state.SetDataSql(this, isFullName, sql); return(sql); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { string sql = state.GetDataSql(this, isFullName); if (sql != null) { return(sql); } object obj = _baseFieldInfo.CreateSqlString(factory, isFullName, state); IEnumerable values = (IEnumerable)LambdaExpressionExtend.ConvertLambdaObject(_collection); List <string> list = new List <string>(); foreach (object item in values) { list.Add(state.AddDataParameter(factory, _baseFieldInfo.ToParameter(item))); } sql = factory.CreateCollectionParamsQuerySql(obj, _isNot ? QueryCollectionPredicate.NotIn : QueryCollectionPredicate.In, list); state.SetDataSql(this, isFullName, sql); return(sql); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { var sql = state.GetDataSql(this, isFullName); if (sql != null) { return(sql); } var objectList = new List <object> (); foreach (var item in _values) { object obj1; var info1 = item as DataFieldInfo; if (!Equals(info1, null)) { obj1 = info1.CreateSqlString(factory, isFullName, state); } else { obj1 = LambdaExpressionExtend.ConvertLambdaObject(item); if (obj1 == null) { obj1 = string.Empty; } else if (!(obj1 is string)) { obj1 = obj1.ToString(); } obj1 = state.AddDataParameter(factory, obj1); } objectList.Add(obj1); } sql = factory.CreateConcatSql(objectList.ToArray()); state.SetDataSql(this, isFullName, sql); return(sql); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { var sql = state.GetDataSql(this, isFullName); if (sql != null) { return(sql); } object left; object right; var leftInfo = _left as DataFieldInfo; var rightInfo = _right as DataFieldInfo; if (!Equals(leftInfo, null) && !Equals(rightInfo, null)) { left = leftInfo.CreateSqlString(factory, isFullName, state); right = rightInfo.CreateSqlString(factory, isFullName, state); } else if (!Equals(leftInfo, null)) { left = leftInfo.CreateSqlString(factory, isFullName, state); var rightObject = LambdaExpressionExtend.ConvertLambdaObject(_right); right = state.AddDataParameter(factory, rightObject); } else if (!Equals(rightInfo, null)) { right = rightInfo.CreateSqlString(factory, isFullName, state); var leftObject = LambdaExpressionExtend.ConvertLambdaObject(_left); left = state.AddDataParameter(factory, leftObject); } else { throw new LightDataException(SR.DataFieldContentError); } switch (_opera) { case MathOperator.Puls: sql = factory.CreatePlusSql(left, right); break; case MathOperator.Minus: sql = factory.CreateMinusSql(left, right); break; case MathOperator.Multiply: sql = factory.CreateMultiplySql(left, right); break; case MathOperator.Divided: sql = factory.CreateDividedSql(left, right); break; case MathOperator.Mod: sql = factory.CreateModSql(left, right); break; case MathOperator.Power: sql = factory.CreatePowerSql(left, right); break; } state.SetDataSql(this, isFullName, sql); return(sql); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { string sql = state.GetDataSql(this, isFullName); if (sql != null) { return(sql); } List <object> objectList = new List <object> (); object obj; DataFieldInfo info = _callObject as DataFieldInfo; if (!Object.Equals(info, null)) { obj = info.CreateSqlString(factory, isFullName, state); } else { obj = LambdaExpressionExtend.ConvertLambdaObject(_callObject); obj = state.AddDataParameter(factory, obj); } if (_argsObjects != null) { foreach (object item in _argsObjects) { object obj1; DataFieldInfo info1 = item as DataFieldInfo; if (!Object.Equals(info1, null)) { obj1 = info1.CreateSqlString(factory, isFullName, state); } else { obj1 = LambdaExpressionExtend.ConvertLambdaObject(item); obj1 = state.AddDataParameter(factory, obj1); } objectList.Add(obj1); } } switch (_function) { case StringFunction.Substring: if (objectList.Count == 2) { sql = factory.CreateSubStringSql(obj, objectList [0], objectList [1]); } else { sql = factory.CreateSubStringSql(obj, objectList [0], null); } break; case StringFunction.IndexOf: if (objectList.Count == 2) { sql = factory.CreateIndexOfSql(obj, objectList [0], objectList [1]); } else { sql = factory.CreateIndexOfSql(obj, objectList [0], null); } break; case StringFunction.Replace: sql = factory.CreateReplaceSql(obj, objectList [0], objectList [1]); break; case StringFunction.ToLower: sql = factory.CreateToLowerSql(obj); break; case StringFunction.ToUpper: sql = factory.CreateToUpperSql(obj); break; case StringFunction.Trim: sql = factory.CreateTrimSql(obj); break; } state.SetDataSql(this, isFullName, sql); return(sql); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { string sql = state.GetDataSql(this, isFullName); if (sql != null) { return(sql); } List <object> objectList = new List <object> (); foreach (object item in _argsObjects) { object obj1; DataFieldInfo info1 = item as DataFieldInfo; if (!Object.Equals(info1, null)) { obj1 = info1.CreateSqlString(factory, isFullName, state); } else { obj1 = LambdaExpressionExtend.ConvertLambdaObject(item); obj1 = state.AddDataParameter(factory, obj1); } objectList.Add(obj1); } switch (_function) { case MathFunction.Abs: sql = factory.CreateAbsSql(objectList [0]); break; case MathFunction.Sign: sql = factory.CreateSignSql(objectList [0]); break; case MathFunction.Sin: sql = factory.CreateSinSql(objectList [0]); break; case MathFunction.Cos: sql = factory.CreateCosSql(objectList [0]); break; case MathFunction.Tan: sql = factory.CreateTanSql(objectList [0]); break; case MathFunction.Atan: sql = factory.CreateAtanSql(objectList [0]); break; case MathFunction.Asin: sql = factory.CreateAsinSql(objectList [0]); break; case MathFunction.Acos: sql = factory.CreateAcosSql(objectList [0]); break; case MathFunction.Atan2: sql = factory.CreateAtan2Sql(objectList [0], objectList [1]); break; case MathFunction.Ceiling: sql = factory.CreateCeilingSql(objectList [0]); break; case MathFunction.Floor: sql = factory.CreateFloorSql(objectList [0]); break; case MathFunction.Round: if (objectList.Count == 2) { sql = factory.CreateRoundSql(objectList [0], objectList [1]); } else { sql = factory.CreateRoundSql(objectList [0], 0); } break; case MathFunction.Truncate: sql = factory.CreateTruncateSql(objectList [0]); break; case MathFunction.Log: if (objectList.Count == 2) { sql = factory.CreateLogSql(objectList [0], objectList [1]); } else { sql = factory.CreateLogSql(objectList [0]); } break; case MathFunction.Log10: sql = factory.CreateLog10Sql(objectList [0]); break; case MathFunction.Exp: sql = factory.CreateExpSql(objectList [0]); break; case MathFunction.Pow: sql = factory.CreatePowSql(objectList [0], objectList [1]); break; case MathFunction.Sqrt: sql = factory.CreateSqrtSql(objectList [0]); break; case MathFunction.Max: sql = factory.CreateMaxSql(objectList [0], objectList [1]); break; case MathFunction.Min: sql = factory.CreateMinSql(objectList [0], objectList [1]); break; } state.SetDataSql(this, isFullName, sql); return(sql); }
internal override string CreateSqlString(CommandFactory factory, bool isFullName, CreateSqlState state) { string sql = null; DataFieldInfo leftInfo = _left as DataFieldInfo; DataFieldInfo rightInfo = _right as DataFieldInfo; if (!Object.Equals(leftInfo, null) && !Object.Equals(rightInfo, null)) { string leftSql = leftInfo.CreateSqlString(factory, isFullName, state); string rightSql = rightInfo.CreateSqlString(factory, isFullName, state); sql = factory.CreateSingleParamSql(leftSql, _predicate, rightSql); } else if (!Object.Equals(leftInfo, null)) { string leftSql = leftInfo.CreateSqlString(factory, isFullName, state); object right = LambdaExpressionExtend.ConvertLambdaObject(_right); if (Object.Equals(right, null)) { bool predicate; if (_predicate == QueryPredicate.Eq) { predicate = true; } else if (_predicate == QueryPredicate.NotEq) { predicate = false; } else { throw new LightDataException(string.Format(SR.UnsupportPredicate, _predicate, "null")); } sql = factory.CreateNullQuerySql(leftSql, predicate); } else if (right is bool) { bool predicate; if (_predicate == QueryPredicate.Eq) { predicate = true; } else if (_predicate == QueryPredicate.NotEq) { predicate = false; } else { throw new LightDataException(string.Format(SR.UnsupportPredicate, _predicate, "bool")); } bool ret = (bool)right; sql = factory.CreateBooleanQuerySql(leftSql, ret, predicate, false); } else { string name = state.AddDataParameter(factory, leftInfo.ToParameter(right)); sql = factory.CreateSingleParamSql(leftSql, _predicate, name); } } else if (!Object.Equals(rightInfo, null)) { string rightSql = rightInfo.CreateSqlString(factory, isFullName, state); object left = LambdaExpressionExtend.ConvertLambdaObject(_left); if (Object.Equals(left, null)) { bool predicate; if (_predicate == QueryPredicate.Eq) { predicate = true; } else if (_predicate == QueryPredicate.NotEq) { predicate = false; } else { throw new LightDataException(string.Format(SR.UnsupportPredicate, _predicate, "null")); } sql = factory.CreateNullQuerySql(rightSql, predicate); } else if (left is bool) { bool predicate; if (_predicate == QueryPredicate.Eq) { predicate = true; } else if (_predicate == QueryPredicate.NotEq) { predicate = false; } else { throw new LightDataException(string.Format(SR.UnsupportPredicate, _predicate, "bool")); } bool ret = (bool)left; sql = factory.CreateBooleanQuerySql(rightSql, ret, predicate, true); } else { string name = state.AddDataParameter(factory, rightInfo.ToParameter(left)); sql = factory.CreateSingleParamSql(name, _predicate, rightSql); } } else { throw new LightDataException(SR.DataFieldContentError); } return(sql); }