public bool Equals(ISqlExpression?other)
{
if (this == other)
{
return(true);
}
if (!(other is SqlGroupingSet otherSet))
{
return(false);
}
if (Items.Count != otherSet.Items.Count)
{
return(false);
}
for (int i = 0; i < Items.Count; i++)
{
if (!Items[i].Equals(otherSet.Items[i]))
{
return(false);
}
}
return(true);
}
// These are both nullable refs, but by construction either _column or _row is set.
public SqlSetExpression(ISqlExpression column, ISqlExpression?expression)
{
Column = column;
Expression = expression;
ValidateColumnExpression(column, expression);
}
public Like(ISqlExpression exp1, bool isNot, ISqlExpression exp2, ISqlExpression?escape, string?functionName = null)
: base(exp1, isNot, SqlQuery.Precedence.Comparison)
{
Expr2 = exp2;
Escape = escape;
FunctionName = functionName;
}
public Like(ISqlExpression exp1, bool isNot, ISqlExpression exp2, ISqlExpression?escape, bool isSqlLike)
: base(exp1, isNot, SqlQuery.Precedence.Comparison)
{
Expr2 = exp2;
Escape = escape;
IsSqlLike = isSqlLike;
}
ISqlExpression?ISqlExpressionWalkable.Walk(WalkOptions options, Func <ISqlExpression, ISqlExpression> func)
{
if (!options.SkipColumnDeclaration)
{
for (var i = 0; i < Columns.Count; i++)
{
var col = Columns[i];
var expr = col.Walk(options, func);
if (expr is SqlColumn column)
{
Columns[i] = column;
}
else
{
Columns[i] = new SqlColumn(col.Parent, expr, col.Alias);
}
}
}
TakeValue = TakeValue?.Walk(options, func);
SkipValue = SkipValue?.Walk(options, func);
return(null);
}
protected override void Walk(WalkOptions options, Func <ISqlExpression, ISqlExpression> func)
{
base.Walk(options, func);
Expr2 = Expr2.Walk(options, func) !;
Escape = Escape?.Walk(options, func);
}
private void RefineDbParameter(ISqlExpression column, ISqlExpression?value)
{
if (value is SqlParameter p && column is SqlField field)
{
if (field.ColumnDescriptor != null && p.Type.SystemType != typeof(object))
{
if (field.ColumnDescriptor.DataType != DataType.Undefined && p.Type.DataType == DataType.Undefined)
{
p.Type = p.Type.WithDataType(field.ColumnDescriptor.DataType);
}
if (field.ColumnDescriptor.DbType != null && p.Type.DbType == null)
{
p.Type = p.Type.WithDbType(field.ColumnDescriptor.DbType);
}
if (field.ColumnDescriptor.Length != null && p.Type.Length == null)
{
p.Type = p.Type.WithLength(field.ColumnDescriptor.Length);
}
if (field.ColumnDescriptor.Precision != null && p.Type.Precision == null)
{
p.Type = p.Type.WithPrecision(field.ColumnDescriptor.Precision);
}
if (field.ColumnDescriptor.Scale != null && p.Type.Scale == null)
{
p.Type = p.Type.WithScale(field.ColumnDescriptor.Scale);
}
}
}
}
internal SqlSelectClause(bool isDistinct, ISqlExpression?takeValue, TakeHints?takeHints, ISqlExpression?skipValue, IEnumerable <SqlColumn> columns)
: base(null)
{
IsDistinct = isDistinct;
TakeValue = takeValue;
TakeHints = takeHints;
SkipValue = skipValue;
Columns.AddRange(columns);
}
public override ISqlExpression GetSubQuery(IBuildContext?context)
{
if (_subQuerySql == null)
{
var cond = new SqlCondition(
_methodCall.Method.Name.StartsWith("All"),
new SqlPredicate.FuncLike(SqlFunction.CreateExists(SelectQuery)));
_subQuerySql = new SqlSearchCondition(cond);
}
return(_subQuerySql);
}
public bool Equals(ISqlExpression?other, Func <ISqlExpression, ISqlExpression, bool> comparer)
{
if (this == other)
{
return(true);
}
return
(other is SqlBinaryExpression expr &&
Operation == expr.Operation &&
SystemType == expr.SystemType &&
Expr1.Equals(expr.Expr1, comparer) &&
Expr2.Equals(expr.Expr2, comparer) &&
comparer(this, other));
}
Expression BuildExpression(int fieldIndex, ISqlExpression?sqlExpression)
{
Expression expr;
if (SequenceHelper.UnwrapSubqueryContext(Sequence) is DefaultIfEmptyBuilder.DefaultIfEmptyContext defaultIfEmpty)
{
expr = Builder.BuildSql(_returnType, fieldIndex, sqlExpression);
if (defaultIfEmpty.DefaultValue != null && expr is ConvertFromDataReaderExpression convert)
{
var generator = new ExpressionGenerator();
expr = convert.MakeNullable();
if (expr.Type.IsNullable())
{
var exprVar = generator.AssignToVariable(expr, "nullable");
var defaultValue = defaultIfEmpty.DefaultValue;
if (defaultValue.Type != expr.Type)
{
var convertLambda = Builder.MappingSchema.GenerateSafeConvert(defaultValue.Type, expr.Type);
defaultValue = InternalExtensions.ApplyLambdaToExpression(convertLambda, defaultValue);
}
var resultVar = generator.AssignToVariable(defaultValue, "result");
generator.AddExpression(Expression.IfThen(
Expression.NotEqual(exprVar, ExpressionInstances.UntypedNull),
Expression.Assign(resultVar, Expression.Convert(exprVar, resultVar.Type))));
generator.AddExpression(resultVar);
expr = generator.Build();
}
}
}
else
if (_methodName == "Sum" || _returnType.IsNullableType())
{
expr = Builder.BuildSql(_returnType, fieldIndex, sqlExpression);
}
else
{
expr = Expression.Block(
Expression.Call(null, MemberHelper.MethodOf(() => CheckNullValue(false, null !)), Expression.Call(ExpressionBuilder.DataReaderParam, Methods.ADONet.IsDBNull, ExpressionInstances.Constant0), Expression.Constant(_methodName)),
Builder.BuildSql(_returnType, fieldIndex, sqlExpression));
}
return(expr);
}
Expression BuildExpression(int fieldIndex, ISqlExpression?sqlExpression)
{
Expression expr;
if (_returnType.IsClass || _methodName == "Sum" || _returnType.IsNullable())
{
expr = Builder.BuildSql(_returnType, fieldIndex, sqlExpression);
}
else
{
expr = Expression.Block(
Expression.Call(null, MemberHelper.MethodOf(() => CheckNullValue(null !, null !)), ExpressionBuilder.DataReaderParam, Expression.Constant(_methodName)),
Builder.BuildSql(_returnType, fieldIndex, sqlExpression));
}
return(expr);
}
public override SqlInfo[] ConvertToIndex(Expression?expression, int level, ConvertFlags flags)
{
switch (flags)
{
case ConvertFlags.Field:
{
var result = _index ??= new[]
{
new SqlInfo
{
Query = Parent !.SelectQuery,
Index = Parent.SelectQuery.Select.Add(Sql !),
Sql = Sql !,
}
};
return(result);
}
}
private void ValidateColumnExpression(ISqlExpression column, ISqlExpression?expression)
{
if (column is SqlRow row)
{
// The length-checks _should_ never failed thanks to C# type-checking.
// We do them in case someone attempts to build invalid expressions with unsafe casts or similar.
if (expression is SelectQuery subquery)
{
var columns = subquery.Select.Columns;
if (columns.Count != row.Values.Length)
{
throw new LinqToDBException("Arity of row expression and subquery do not match.");
}
for (int i = 0; i < row.Values.Length; i++)
{
RefineDbParameter(row.Values[i], columns[i].Expression);
}
}
else if (expression is SqlRow sqlRow)
{
var values = sqlRow.Values;
if (values.Length != row.Values.Length)
{
throw new LinqToDBException("Arity of row expressions do not match.");
}
for (int i = 0; i < values.Length; i++)
{
RefineDbParameter(values[i], values[i]);
}
}
else if (expression != null)
{
throw new ArgumentException("An array of expressions can only be SET to a subquery or row expression", nameof(expression));
}
}
else
{
RefineDbParameter(column, expression);
}
}
Expression BuildExpression(int fieldIndex, ISqlExpression?sqlExpression)
{
Expression expr;
if (Sequence is DefaultIfEmptyBuilder.DefaultIfEmptyContext defaultIfEmpty)
{
expr = Builder.BuildSql(_returnType, fieldIndex, sqlExpression);
if (defaultIfEmpty.DefaultValue != null && expr is ConvertFromDataReaderExpression convert)
{
var generator = new ExpressionGenerator();
expr = convert.MakeNullable();
if (expr.Type.IsNullable())
{
var exprVar = generator.AssignToVariable(expr, "nullable");
var resultVar = generator.AssignToVariable(defaultIfEmpty.DefaultValue, "result");
generator.AddExpression(Expression.IfThen(
Expression.NotEqual(exprVar, Expression.Constant(null)),
Expression.Assign(resultVar, Expression.Convert(exprVar, resultVar.Type))));
generator.AddExpression(resultVar);
expr = generator.Build();
}
}
}
else
if (_returnType.IsClass || _methodName == "Sum" || _returnType.IsNullable())
{
expr = Builder.BuildSql(_returnType, fieldIndex, sqlExpression);
}
else
{
expr = Expression.Block(
Expression.Call(null, MemberHelper.MethodOf(() => CheckNullValue(false, null !)), Expression.Call(ExpressionBuilder.DataReaderParam, Methods.ADONet.IsDBNull, Expression.Constant(0)), Expression.Constant(_methodName)),
Builder.BuildSql(_returnType, fieldIndex, sqlExpression));
}
return(expr);
}
SqlField RegisterCteField(ISqlExpression?baseExpression, ISqlExpression expression, int index, string?alias)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
var cteField = _cte.RegisterFieldMapping(index, () =>
{
var f = QueryHelper.GetUnderlyingField(baseExpression ?? expression);
var newField = f == null
? new SqlField(expression.SystemType !, alias, expression.CanBeNull)
: new SqlField(f);
if (alias != null)
{
newField.Name = alias;
}
newField.PhysicalName = newField.Name;
return(newField);
});
public SqlSetExpression(ISqlExpression column, ISqlExpression?expression)
{
Column = column;
Expression = expression;
if (expression is SqlParameter p)
{
if (column is SqlField field)
{
if (field.ColumnDescriptor != null && p.Type.SystemType != typeof(object))
{
if (field.ColumnDescriptor.DataType != DataType.Undefined && p.Type.DataType == DataType.Undefined)
{
p.Type = p.Type.WithDataType(field.ColumnDescriptor.DataType);
}
if (field.ColumnDescriptor.DbType != null && p.Type.DbType == null)
{
p.Type = p.Type.WithDbType(field.ColumnDescriptor.DbType);
}
if (field.ColumnDescriptor.Length != null && p.Type.Length == null)
{
p.Type = p.Type.WithLength(field.ColumnDescriptor.Length);
}
if (field.ColumnDescriptor.Precision != null && p.Type.Precision == null)
{
p.Type = p.Type.WithPrecision(field.ColumnDescriptor.Precision);
}
if (field.ColumnDescriptor.Scale != null && p.Type.Scale == null)
{
p.Type = p.Type.WithScale(field.ColumnDescriptor.Scale);
}
}
}
}
}
public override ISqlExpression GetSubQuery(IBuildContext?context)
{
if (_subQuerySql == null)
{
var args = _methodCall.Method.GetGenericArguments();
var param = Expression.Parameter(args[0], "param");
var expr = _methodCall.Arguments[1];
var condition = Expression.Lambda(ExpressionBuilder.Equal(Builder.MappingSchema, param, expr), param);
IBuildContext ctx = new ExpressionContext(Parent, Sequence, condition);
ctx = Builder.GetContext(ctx, expr) ?? ctx;
Builder.ReplaceParent(ctx, this);
SqlCondition cond;
if ((Sequence.SelectQuery != SelectQuery || _buildInStatement) &&
(ctx.IsExpression(expr, 0, RequestFor.Field).Result ||
ctx.IsExpression(expr, 0, RequestFor.Expression).Result))
{
Sequence.ConvertToIndex(null, 0, ConvertFlags.All);
var ex = Builder.ConvertToSql(ctx, _methodCall.Arguments[1]);
cond = new SqlCondition(false, new SqlPredicate.InSubQuery(ex, false, SelectQuery));
}
else
{
var sequence = Builder.BuildWhere(Parent, Sequence, condition, true);
cond = new SqlCondition(false, new SqlPredicate.FuncLike(SqlFunction.CreateExists(sequence.SelectQuery)));
}
_subQuerySql = new SqlSearchCondition(cond);
}
return(_subQuerySql);
}
public override ISqlExpression EscapeLikeCharacters(ISqlExpression expression, ref ISqlExpression?escape)
{
throw new LinqException("Access does not support `Replace` function which is required for such query.");
}
public bool Equals(ISqlExpression?other)
{
return(other != null && other.GetType() == GetType());
}
public SqlSelectClause Take(ISqlExpression?value, TakeHints?hints)
{
TakeHints = hints;
TakeValue = value;
return(this);
}
ISqlExpression?ISqlExpressionWalkable.Walk(WalkOptions options, Func <ISqlExpression, ISqlExpression> func)
{
Column = Column.Walk(options, func) !;
Expression = Expression?.Walk(options, func);
return(null);
}
bool IEquatable <ISqlExpression> .Equals(ISqlExpression?other)
{
return(this == other);
}
public Expression BuildSql(Type type, int idx, ISqlExpression?sourceExpression)
{
return(BuildSql(type, idx, QueryHelper.GetValueConverter(sourceExpression)));
}
ISqlExpression?ISqlExpressionWalkable.Walk <TContext>(WalkOptions options, TContext context, Func <TContext, ISqlExpression, ISqlExpression> func)
{
Column = Column.Walk(options, context, func) !;
Expression = Expression?.Walk(options, context, func);
return(null);
}
public bool GetIsSkipSupportedFlag(ISqlExpression?takeExpression, ISqlExpression?skipExpression)
{
return(IsSkipSupported || IsSkipSupportedIfTake && takeExpression != null);
}
bool IEquatable <ISqlExpression> .Equals(ISqlExpression?other)
{
return(Equals(other, DefaultComparer));
}
bool IEquatable <ISqlExpression> .Equals(ISqlExpression?other)
{
throw new NotImplementedException();
}
