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