protected override Expression VisitIn(InExpression expression)
{
if (!ShouldRewrite(expression)) {
return base.VisitIn(expression);
}
Array array = expression.Values.OfType<ConstantExpression>().Select(item => item.Value).Distinct().ToArray();
var vfpDataXml = new ArrayXmlToCursor(array);
var tableAlias = new TableAlias();
var columnType = _language.TypeSystem.GetColumnType(vfpDataXml.ItemType);
var columnExpression = new ColumnExpression(vfpDataXml.ItemType, columnType, tableAlias, ArrayXmlToCursor.ColumnName);
var columns = new List<ColumnDeclaration> {
new ColumnDeclaration(string.Empty, columnExpression, columnType)
};
var xml = Expression.Constant(vfpDataXml.Xml);
var cursorName = Expression.Constant("curTemp_" + DateTime.Now.ToString("ddHHssmm"));
var check = Expression.GreaterThan(new XmlToCursorExpression(xml, cursorName), Expression.Constant(0));
var from = Expression.Condition(check, cursorName, Expression.Constant(string.Empty));
var select = new SelectExpression(tableAlias, columns, from, null);
return new InExpression(expression.Expression, select);
}
protected internal override Expression VisitIn(InExpression @in)
{
if (@in.Select != null)
{
AddSingleColumn(@in);
}
return base.VisitIn(@in);
}
public void Contains_call_on_generic_list_of_int_is_parsed_into_InExpression_with_property_name_and_values()
{
var pageCounts = new List<int> { 0, 1 };
var expression = _parser.Parse<Book>(x => pageCounts.Contains(x.PageCount));
var expectedExpression = new InExpression(
new PropertyExpression("PageCount", typeof(int)),
new ArrayValueExpression(pageCounts));
Assert.AreEqual(expectedExpression, expression);
}
public void Contains_call_on_generic_list_of_string_is_parsed_into_InExpression_with_property_name_and_values()
{
IList<string> titles = new List<string> { "Title 1", "Title 2" };
var expression = _parser.Parse<Book>(x => titles.Contains(x.Title));
var expectedExpression = new InExpression(
new PropertyExpression("Title", typeof(string)),
new ArrayValueExpression(titles));
Assert.AreEqual(expectedExpression, expression);
}
protected virtual Expression VisitIn(InExpression expression)
{
_expressionInProgress.Enqueue(new GroupStartFragment());
Visit(expression.Subject);
_expressionInProgress.Enqueue(new StringFragment(" IN "));
Visit(expression.Target);
_expressionInProgress.Enqueue(new GroupEndFragment());
return(expression);
}
protected override Expression VisitIn(InExpression inExpression)
{
var parentSearchCondition = _isSearchCondition;
_isSearchCondition = false;
var item = (SqlExpression)Visit(inExpression.Item);
var subquery = (SelectExpression)Visit(inExpression.Subquery);
var values = (SqlExpression)Visit(inExpression.Values);
_isSearchCondition = parentSearchCondition;
return(ApplyConversion(inExpression.Update(item, values, subquery), condition: true));
}
public void Contains_call_on_generic_list_of_int_is_parsed_into_InExpression_with_property_name_and_values()
{
var pageCounts = new List <int> {
0, 1
};
var expression = _parser.Parse <Book>(x => pageCounts.Contains(x.PageCount));
var expectedExpression = new InExpression(
new PropertyExpression("PageCount", typeof(int)),
new ArrayValueExpression(pageCounts));
Assert.AreEqual(expectedExpression, expression);
}
private void DoTestEvaluate(object value, IReadOnlyCollection <object> list, bool expected)
{
// Arrange
Literal literal = new Literal(value, LiteralType.Value);
IReadOnlyCollection <Literal> literals = list.Select(item => new Literal(item, LiteralType.Value)).ToList();
IExpression expression = new InExpression(literal, literals);
// Act
bool result = expression.Evaluate(null);
// Assert
Assert.AreEqual(expected, result);
}
public void Contains_call_on_generic_list_of_string_is_parsed_into_InExpression_with_property_name_and_values()
{
IList <string> titles = new List <string> {
"Title 1", "Title 2"
};
var expression = _parser.Parse <Book>(x => titles.Contains(x.Title));
var expectedExpression = new InExpression(
new PropertyExpression("Title", typeof(string)),
new ArrayValueExpression(titles));
Assert.AreEqual(expectedExpression, expression);
}
protected override Expression VisitIn(InExpression inExpression)
{
Check.NotNull(inExpression, nameof(inExpression));
var parentOptimize = _optimize;
_optimize = false;
var item = (SqlExpression)Visit(inExpression.Item);
var subquery = (SelectExpression)Visit(inExpression.Subquery);
var values = (SqlExpression)Visit(inExpression.Values);
_optimize = parentOptimize;
return(ApplyConversion(inExpression.Update(item, values, subquery), condition: true));
}
public override void VisitInExpression(InExpression inExpression)
{
if (inExpression.Values == null)
{
throw new SqlErrorException("IN predicate only supports a list of values right now");
}
Expression memberExpression;
if (inExpression.Expression is ColumnReference columnReferenceExpression)
{
//Check here if any index can be used aswell
var identifiers = columnReferenceExpression.Identifiers;
identifiers = MemberUtils.RemoveAlias(_previousStage, identifiers);
memberExpression = MemberUtils.GetMember(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property);
AddUsedProperty(property);
AddNameToStack(string.Join(".", identifiers));
}
else
{
throw new SqlErrorException("IN predicate can only be used against column names");
}
IList list = ListUtils.GetNewListFunction(memberExpression.Type)();
foreach (var value in inExpression.Values)
{
if (value is Literal literal)
{
list.Add(TypeConvertUtils.ConvertToType(literal.GetValue(), memberExpression.Type));
}
else if (value is VariableReference variableReference)
{
var sqlParameter = _visitorMetadata.Parameters.GetParameter(variableReference.Name);
var variableValue = sqlParameter.GetValue(memberExpression.Type);
list.Add(variableValue);
}
else
{
throw new SqlErrorException("IN predicate only supports literal or parameter values.");
}
}
var inPredicate = _visitorMetadata.OperationsProvider.GetListContains(memberExpression, list);
AddExpressionToStack(inPredicate);
}
public void InBoolean_GivenElementAndSet_CorrectValueReturned(int[] a, int[] b, bool expected)
{
Element lhsValue = new Element(a.ToList());
Set rhsValue = GetSetWith1DElements(b);
ElementExpression lhs = new ElementExpression(null, 0, 0);
SetExpression rhs = GetSetInit();
InExpression expression = new InExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
DispatchElementForParent(lhsValue, lhs, parent);
DispatchSetForParent(rhsValue, rhs, parent);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.InBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
protected internal virtual Expression VisitIn(InExpression @in)
{
var expression = this.Visit(@in.Expression);
var select = (SelectExpression?)this.Visit(@in.Select);
if (expression != @in.Expression || select != @in.Select)
{
if (select != null)
{
return(new InExpression(expression, select));
}
else
{
return(InExpression.FromValues(expression, @in.Values !));
}
}
return(@in);
}
public virtual Expression VisitIn(InExpression inExpression)
{
if (inExpression.Values != null)
{
var inValues = ProcessInExpressionValues(inExpression.Values);
var inValuesNotNull = ExtractNonNullExpressionValues(inValues);
if (inValues.Count != inValuesNotNull.Count)
{
var relationalNullsInExpression
= Expression.OrElse(
new InExpression(inExpression.Operand, inValuesNotNull),
new IsNullExpression(inExpression.Operand));
return(Visit(relationalNullsInExpression));
}
if (inValuesNotNull.Count > 0)
{
Visit(inExpression.Operand);
_relationalCommandBuilder.Append(" IN (");
VisitJoin(inValuesNotNull);
_relationalCommandBuilder.Append(")");
}
else
{
_relationalCommandBuilder.Append("1 = 0");
}
}
else
{
Visit(inExpression.Operand);
_relationalCommandBuilder.Append(" IN ");
Visit(inExpression.SubQuery);
}
return(inExpression);
}
protected virtual Expression VisitNotIn([NotNull] InExpression inExpression)
{
if (inExpression.Values != null)
{
var inValues = ProcessInExpressionValues(inExpression.Values);
var inValuesNotNull = ExtractNonNullExpressionValues(inValues);
if (inValues.Count != inValuesNotNull.Count)
{
var relationalNullsNotInExpression
= Expression.AndAlso(
Expression.Not(new InExpression(inExpression.Operand, inValuesNotNull)),
Expression.Not(new IsNullExpression(inExpression.Operand)));
return(Visit(relationalNullsNotInExpression));
}
if (inValues.Count > 0)
{
Visit(inExpression.Operand);
_relationalCommandBuilder.Append(" NOT IN (");
VisitJoin(inValues);
_relationalCommandBuilder.Append(")");
}
else
{
_relationalCommandBuilder.Append("1 = 1");
}
}
else
{
Visit(inExpression.Operand);
_relationalCommandBuilder.Append(" NOT IN ");
Visit(inExpression.SubQuery);
}
return(inExpression);
}
public void TestVisitInExpression()
{
Mock <ScalarExpression> expMock = new Mock <ScalarExpression>();
Mock <ScalarExpression> valueMock = new Mock <ScalarExpression>();
InExpression inExpression = new InExpression()
{
Expression = expMock.Object,
Values = new List <ScalarExpression>()
{
valueMock.Object
}
};
KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor();
koraliumSqlVisitor.Visit(inExpression);
expMock.Verify(x => x.Accept(koraliumSqlVisitor));
valueMock.Verify(x => x.Accept(koraliumSqlVisitor));
}
protected virtual Expression VisitNotInExpression(InExpression inExpression)
{
var inValues = ProcessInExpressionValues(inExpression.Values);
if (inValues.Count > 0)
{
VisitExpression(inExpression.Column);
_sql.Append(" NOT IN (");
VisitJoin(inValues);
_sql.Append(")");
}
else
{
_sql.Append("1 = 1");
}
return(inExpression);
}
public virtual Expression VisitInExpression(InExpression inExpression)
{
var inValues = ProcessInExpressionValues(inExpression.Values);
if (inValues.Count > 0)
{
VisitExpression(inExpression.Column);
_sql.Append(" IN (");
VisitJoin(inValues);
_sql.Append(")");
}
else
{
_sql.Append("1 = 0");
}
return(inExpression);
}
private static bool ShouldRewrite(InExpression @in)
{
if (@in.Values == null || @in.Values.Count == 0 || @in.Values[0].NodeType != ExpressionType.Constant) {
return false;
}
const int MINLENGTH = 250;
var values = new StringBuilder();
foreach (var value in @in.Values.Where(value => value != null).Distinct()) {
values.Append(value);
values.Append(",");
if (values.Length > MINLENGTH) {
return true;
}
}
return false;
}
protected override Expression VisitIn(InExpression inExpression)
{
var canOptimize = _canOptimize;
_canOptimize = false;
_isNullable = false;
var item = (SqlExpression)Visit(inExpression.Item);
var isNullable = _isNullable;
_isNullable = false;
var subquery = (SelectExpression)Visit(inExpression.Subquery);
isNullable |= _isNullable;
_isNullable = false;
var values = (SqlExpression)Visit(inExpression.Values);
_isNullable |= isNullable;
_canOptimize = canOptimize;
return(inExpression.Update(item, values, subquery));
}
private static IEnumerable <(string Value, ValueTokenType Type)> GetValuesForIn(
JsonOperationContext context,
Query query,
InExpression expression,
QueryMetadata metadata,
BlittableJsonReaderObject parameters,
string fieldName)
{
foreach (var val in expression.Values)
{
var valueToken = val as ValueExpression;
if (valueToken == null)
{
ThrowInvalidInValue(query, parameters, val);
}
foreach (var(value, type) in GetValues(fieldName, query, metadata, parameters, valueToken))
{
string valueAsString;
switch (type)
{
case ValueTokenType.Long:
var valueAsLong = (long)value;
valueAsString = valueAsLong.ToString(CultureInfo.InvariantCulture);
break;
case ValueTokenType.Double:
var valueAsDbl = (double)value;
valueAsString = valueAsDbl.ToString("G");
break;
default:
valueAsString = value?.ToString();
break;
}
yield return(valueAsString, type);
}
}
}
public void Visit(InExpression expression)
{
if (expression.ArrayValueExpression.Values.IsEmpty())
{
throw new WeenyMapperException("Can not generate IN constraint from empty collection");
}
var columnName = expression.PropertyExpression.PropertyName;
var newParameters = new List <CommandParameter>();
foreach (var value in expression.ArrayValueExpression.Values)
{
var commandParameter = _commandParameterFactory.Create(columnName, value);
CommandParameters.Add(commandParameter);
newParameters.Add(commandParameter);
}
var parameterString = string.Join(", ", newParameters.Select(x => x.ReferenceName));
var columnNameString = CreateColumnNameString(expression.PropertyExpression.PropertyName);
ConstraintCommandText = string.Format("({0} IN ({1}))", columnNameString, parameterString);
}
public void Visit(InExpression expression)
{
var values = expression.ArrayValueExpression.Values;
if (values.IsEmpty())
{
throw new WeenyMapperException("Can not generate IN constraint from empty collection");
}
var columnName = expression.PropertyExpression.PropertyName;
var actualValue = _row.GetColumnValue(columnName).Value;
foreach (var value in values)
{
if (Equals(value, actualValue))
{
return;
}
}
_isMatch = false;
}
protected virtual Expression VisitIn(InExpression inExpression)
{
Expression expression = Visit(inExpression.Expression);
if (inExpression.Query != null)
{
SelectExpression select = (SelectExpression)Visit(inExpression.Query);
if (expression != inExpression.Expression || select != inExpression.Query)
{
return(new InExpression(expression, select));
}
}
else
{
ReadOnlyCollection <Expression> values = Visit(inExpression.Values);
if (expression != inExpression.Expression || values != inExpression.Values)
{
return(new InExpression(expression, values));
}
}
return(inExpression);
}
public object VisitIn(InExpression expression, Context context)
{
_queryBuilder.AppendFormat("ARRAY_CONTAINS([");
var values = expression.Values.ToArray();
for (int i = 0; i < values.Length; i++)
{
string paramName = AddParameterMapping(values[i]);
_queryBuilder.Append(paramName);
if (i < values.Length - 1)
{
_queryBuilder.Append(',');
}
}
_queryBuilder.Append("], ");
_queryBuilder.Append(context.InstanceVariableName).Append('.').Append(GetFieldName(expression, context)).Append(')');
return(null);
}
public void TestInExpressionSingleValue()
{
var actual = new InExpression()
{
Expression = new ColumnReference()
{
Identifiers = new List <string>()
{
"c1"
}
},
Values = new List <ScalarExpression>()
{
new StringLiteral()
{
Value = "a"
}
}
}.Print();
var expected = "c1 IN ('a')";
actual.Should().Be(expected);
}
private ICriterion BuildCriterion(QueryMember member, IEnumerator values)
{
ICriterion criterion;
WhereOperator wo;
if (!Enum.TryParse(member.Type.ToString(), out wo))
{
wo = WhereOperator.Equal;
}
switch (wo)
{
case WhereOperator.Between:
criterion = new BetweenExpression(member.PropertyName, values.NextValue(), values.NextValue());
break;
case WhereOperator.In:
criterion = new InExpression(member.PropertyName, values.NextValue <object[]>());
break;
case WhereOperator.Null:
criterion = new NullExpression(member.PropertyName);
break;
default:
criterion = new SimpleExpression(member.PropertyName, wo, values.NextValue());
break;
}
if (member.HasNot)
{
criterion = new NotExpression(criterion);
}
return(criterion);
}
public override void VisitInExpression(InExpression inExpression)
{
if (!(inExpression.Expression is ColumnReference column))
{
//TODO: Fix exception
throw new System.Exception("In expressions can only be done on columns for elasticseach filters");
}
List <object> values = new List <object>();
foreach (var val in inExpression.Values)
{
if (!(val is Literal literal))
{
throw new System.Exception("In expression can only have literals as valeus for elasticsearch filters");
}
values.Add(GetTerm(literal.GetValue()));
}
Push(new Terms()
{
FieldName = string.Join(".", column.Identifiers),
Values = values
});
}
private static bool ShouldRewrite(InExpression @in)
{
if (@in.Values == null || @in.Values.Count == 0 || @in.Values[0].NodeType != ExpressionType.Constant)
{
return(false);
}
const int MINLENGTH = 250;
var values = new StringBuilder();
foreach (var value in @in.Values.Where(value => value != null).Distinct())
{
values.Append(value);
values.Append(",");
if (values.Length > MINLENGTH)
{
return(true);
}
}
return(false);
}
public ISymbolValue Visit(InExpression x)
{
// The return value of the InExpression is null if the element is not in the array;
// if it is in the array it is a pointer to the element.
return x.RightOperand != null ? x.RightOperand.Accept(this) : null;
}
IExpression CmpExpression(IBlockNode Scope = null)
{
// TODO: Make this into a switch.
var left = ShiftExpression(Scope);
OperatorBasedExpression ae;
switch (laKind) {
case DTokens.Equal:
case DTokens.NotEqual:
ae = new EqualExpression (laKind == NotEqual);
break;
case DTokens.LessThan:
case DTokens.LessEqual:
case DTokens.GreaterThan:
case DTokens.GreaterEqual:
case DTokens.Unordered:
case DTokens.LessOrGreater:
case DTokens.LessEqualOrGreater:
case DTokens.UnorderedOrGreater:
case DTokens.UnorderedGreaterOrEqual:
case DTokens.UnorderedOrLess:
case DTokens.UnorderedLessOrEqual:
case DTokens.UnorderedOrEqual:
ae = new RelExpression (laKind);
break;
case DTokens.Is:
ae = new IdentityExpression (false);
break;
case DTokens.In:
ae = new InExpression (false);
break;
case Not:
switch (Peek (1).Kind) {
case DTokens.Is:
ae = new IdentityExpression (false);
Step ();
break;
case DTokens.In:
ae = new InExpression (true);
Step ();
break;
default:
return left;
}
break;
default:
return left;
}
// Skip operator
Step();
ae.LeftOperand = left;
ae.RightOperand = ShiftExpression(Scope);
return ae;
}
IExpression CmpExpression(IBlockNode Scope = null)
{
// TODO: Make this into a switch.
var left = ShiftExpression(Scope);
OperatorBasedExpression ae = null;
// Equality Expressions
if (laKind == Equal || laKind == NotEqual)
ae = new EqualExpression(laKind == NotEqual);
// Relational Expressions
else if (IsRelationalOperator(laKind))
ae = new RelExpression(laKind);
// Identity Expressions
else if (laKind == Is || (laKind == Not && Peek(1).Kind == Is))
ae = new IdentityExpression(laKind == Not);
// In Expressions
else if (laKind == In || (laKind == Not && Peek(1).Kind == In))
ae = new InExpression(laKind == Not);
else return left;
// Skip possible !-Token
if (laKind == Not)
Step();
// Skip operator
Step();
ae.LeftOperand = left;
ae.RightOperand = ShiftExpression(Scope);
return ae;
}
protected override Expression VisitIn(InExpression @in)
{
VisitValue(@in.Expression);
sb.Append(" IN (");
if (@in.Select != null)
{
Visit(@in.Select);
sb.Append(")");
}
else if (@in.Values == null)
{
return @in;
}
for (int i = 0, n = @in.Values.Count; i < n; i++)
{
if (i > 0)
sb.Append(", ");
VisitValue(@in.Values[i]);
}
sb.Append(")");
return @in;
}
protected virtual Expression VisitIn(InExpression @in)
{
Expression expr = this.Visit(@in.Expression);
if (@in.Select != null)
{
SelectExpression select = (SelectExpression)this.Visit(@in.Select);
if (expr != @in.Expression || select != @in.Select)
{
return new InExpression(expr, select);
}
}
else
{
IEnumerable<Expression> values = this.VisitExpressionList(@in.Values);
if (expr != @in.Expression || values != @in.Values)
{
return new InExpression(expr, values);
}
}
return @in;
}
protected override Expression VisitIn(InExpression inExpression)
{
if (inExpression.Values != null)
{
var inValues = new List <SqlConstantExpression>();
var hasNullValue = false;
switch (inExpression.Values)
{
case SqlConstantExpression sqlConstant:
{
var values = (IEnumerable)sqlConstant.Value;
foreach (var value in values)
{
if (value == null)
{
hasNullValue = true;
continue;
}
inValues.Add(
new SqlConstantExpression(
Expression.Constant(value),
sqlConstant.TypeMapping));
}
}
break;
case SqlParameterExpression sqlParameter:
{
var values = (IEnumerable)_parametersValues[sqlParameter.Name];
foreach (var value in values)
{
if (value == null)
{
hasNullValue = true;
continue;
}
inValues.Add(
new SqlConstantExpression(
Expression.Constant(value),
sqlParameter.TypeMapping));
}
}
break;
}
if (inValues.Count > 0)
{
if (hasNullValue)
{
_relationalCommandBuilder.Append("(");
}
Visit(inExpression.Item);
_relationalCommandBuilder.Append(inExpression.Negated ? " NOT IN " : " IN ");
_relationalCommandBuilder.Append("(");
GenerateList(inValues, e => Visit(e));
_relationalCommandBuilder.Append(")");
if (hasNullValue)
{
_relationalCommandBuilder.Append(_operatorMap[ExpressionType.OrElse]);
Visit(new SqlUnaryExpression(
ExpressionType.Equal, inExpression.Item, inExpression.Type, inExpression.TypeMapping));
_relationalCommandBuilder.Append(")");
}
}
else
{
Visit(
hasNullValue
? (Expression) new SqlUnaryExpression(
ExpressionType.Equal, inExpression.Item, inExpression.Type, inExpression.TypeMapping)
: new SqlBinaryExpression(
ExpressionType.Equal,
new SqlConstantExpression(Expression.Constant(true), inExpression.TypeMapping),
new SqlConstantExpression(Expression.Constant(false), inExpression.TypeMapping),
typeof(bool),
inExpression.TypeMapping));
}
}
else
{
Visit(inExpression.Item);
_relationalCommandBuilder.Append(inExpression.Negated ? " NOT IN " : " IN ");
_relationalCommandBuilder.AppendLine("(");
using (_relationalCommandBuilder.Indent())
{
Visit(inExpression.Subquery);
}
_relationalCommandBuilder.AppendLine().AppendLine(")");
}
return(inExpression);
}
internal static void PatchInExpressions(this InExpression expression, RelationalQueryContext context, List <string> usedParams = null)
{
if (context is null ||
expression is null)
{
return;
}
expression.Item.PatchInExpressions(context, usedParams);
expression.Subquery?.PatchInExpressions(context, usedParams);
if (expression.Values is null)
{
return;
}
// The version of VisitIn in EF Core 3.1.1 has two requirements.
// 1) The Values must be from a SqlConstantExpression
// 2) The Value from the SqlConstantExpression must be castable to IEnumerable<object>
var currentValue = expression.Values;
switch (currentValue)
{
case SqlParameterExpression paramEx:
{
// Fix issue 1 & 2 by grabbing the parameter and converting to a constant IEnumerable<object>.
var value = context.ParameterValues[paramEx.Name];
if (usedParams != null &&
!usedParams.Contains(paramEx.Name))
{
usedParams.Add(paramEx.Name);
}
var newVal = (value as IEnumerable)?.Cast <object>().ToArray() ?? new object[0];
var newEx = new SqlConstantExpression(Expression.Constant(newVal), paramEx.TypeMapping);
if (!expression.SetNonPublicProperty("Values", newEx))
{
throw new InvalidOperationException("Could not update Values for InExpression.");
}
break;
}
case SqlConstantExpression sqlConstEx:
{
// Fix issue 2, castable to IEnumerable<object>
var constEx = sqlConstEx.GetNonPublicField <ConstantExpression>("_constantExpression");
var newVal = ((IEnumerable)constEx.Value).Cast <object>().ToArray();
var newEx = new SqlConstantExpression(Expression.Constant(newVal), sqlConstEx.TypeMapping);
if (!expression.SetNonPublicProperty("Values", newEx))
{
throw new InvalidOperationException("Could not update Values for InExpression.");
}
break;
}
default:
throw new InvalidOperationException($"Don't know how to convert {currentValue.GetType()} to SqlConstantExpression.");
}
}
private bool IsValidInExpression(InExpression expression)
{
return expression != null && _inExpressions.Contains(VfpFormatter.Format(expression));
}
protected virtual Expression VisitIn(InExpression @in)
{
var expression = this.Visit(@in.Expression);
var select = (SelectExpression)this.Visit(@in.Select);
if (expression != @in.Expression || select != @in.Select)
{
if (select != null)
return new InExpression(expression, select);
else
return InExpression.FromValues(expression, @in.Values);
}
return @in;
}
IExpression CmpExpression(IBlockNode Scope = null)
{
var left = ShiftExpression(Scope);
OperatorBasedExpression ae = null;
// Equality Expressions
if (laKind == Equal || laKind == NotEqual)
ae = new EqualExpression(laKind == NotEqual);
// Relational Expressions
else if (RelationalOperators[laKind])
ae = new RelExpression(laKind);
// Identity Expressions
else if (laKind == Is || (laKind == Not && Peek(1).Kind == Is))
ae = new IdendityExpression(laKind == Not);
// In Expressions
else if (laKind == In || (laKind == Not && Peek(1).Kind == In))
ae = new InExpression(laKind == Not);
else return left;
LastParsedObject = ae;
// Skip possible !-Token
if (laKind == Not)
Step();
// Skip operator
Step();
ae.LeftOperand = left;
ae.RightOperand = ShiftExpression(Scope);
return ae;
}
private Expression BindContains(Expression source, Expression match, bool isRoot)
{
ConstantExpression constSource = source as ConstantExpression;
if (constSource != null && !IsQuery(constSource))
{
Debug.Assert(!isRoot);
List<Expression> values = new List<Expression>();
foreach (object value in (IEnumerable) constSource.Value)
{
values.Add(Expression.Constant(Convert.ChangeType(value, match.Type), match.Type));
}
match = Visit(match);
return new InExpression(match, values);
}
else
{
ProjectionExpression projection = VisitSequence(source);
match = Visit(match);
Expression result = new InExpression(match, projection.Source);
if (isRoot)
{
return GetSingletonSequence(result, "SingleOrDefault");
}
return result;
}
}
protected virtual Expression VisitIn(InExpression @in)
{
var expr = this.Visit(@in.Expression);
var select = (SelectExpression)this.Visit(@in.Select);
var values = this.VisitExpressionList(@in.Values);
return this.UpdateIn(@in, expr, select, values);
}
protected InExpression UpdateIn(InExpression @in, Expression expression, SelectExpression select, IEnumerable<Expression> values)
{
if (expression != @in.Expression || select != @in.Select || values != @in.Values)
{
if (select != null)
{
return new InExpression(expression, select);
}
else
{
return new InExpression(expression, values);
}
}
return @in;
}
public void Visit(InExpression expression)
{
var values = expression.ArrayValueExpression.Values;
if (values.IsEmpty())
{
throw new WeenyMapperException("Can not generate IN constraint from empty collection");
}
var columnName = expression.PropertyExpression.PropertyName;
var actualValue = _row.GetColumnValue(columnName).Value;
foreach (var value in values)
{
if (Equals(value, actualValue))
return;
}
_isMatch = false;
}
protected override Expression VisitIn(InExpression @in)
{
if (@in.Values != null)
return base.VisitIn(@in);
else
using (Scope())
return base.VisitIn(@in);
}
protected override Expression VisitIn(InExpression @in)
{
if (@in.Values != null)
{
if (@in.Values.Count == 0)
{
this.Write("0 <> 0");
}
else
{
this.VisitValue(@in.Expression);
this.Write(" IN (");
for (int i = 0, n = @in.Values.Count; i < n; i++)
{
if (i > 0) this.Write(", ");
this.VisitValue(@in.Values[i]);
}
this.Write(")");
}
}
else
{
this.VisitValue(@in.Expression);
this.Write(" IN (");
this.WriteLine(Indentation.Inner);
this.Visit(@in.Select);
this.WriteLine(Indentation.Same);
this.Write(")");
this.Indent(Indentation.Outer);
}
return @in;
}
public void Visit(InExpression x)
{
}
ISemantic E(InExpression x, ISemantic l=null)
{
// The return value of the InExpression is null if the element is not in the array;
// if it is in the array it is a pointer to the element.
return E(x.RightOperand);
}
public AbstractType Visit(InExpression x)
{
return(x.RightOperand != null?x.RightOperand.Accept(this) : null);
}
protected override Expression VisitIn(InExpression @in)
{
if (@in.Select != null)
{
this.VisitValue(@in.Expression);
sb.Append(" IN (");
this.AppendNewLine(Indentation.Inner);
this.Visit(@in.Select);
this.AppendNewLine(Indentation.Same);
sb.Append(")");
this.Indent(Indentation.Outer);
}
else if (@in.Values != null)
{
if (@in.Values.Any())
{
this.VisitValue(@in.Expression);
sb.Append(" IN (");
for (int i = 0, n = @in.Values.Count; i < n; i++)
{
if (i > 0) sb.Append(", ");
this.VisitValue(@in.Values[i]);
}
sb.Append(")");
}
else
{
//If Values is empty, the generated string "ColumnName IN ()" is invalid sql, but
// that logic should always return false, so we can just replace it with a false statement
sb.Append(" 1 = 0 ");
}
}
else
{
throw new Exception("Either .Values or .Select must be populated.");
}
return @in;
}
private Expression BindContains(Expression source, Expression match, bool isRoot)
{
ConstantExpression constSource = source as ConstantExpression;
if (constSource != null && !IsQuery(constSource))
{
System.Diagnostics.Debug.Assert(!isRoot);
List<Expression> values = new List<Expression>();
foreach (object value in (IEnumerable)constSource.Value)
{
values.Add(Expression.Constant(Convert.ChangeType(value, match.Type), match.Type));
}
match = this.Visit(match);
return new InExpression(match, values);
}
else if (isRoot && !this.language.AllowSubqueryInSelectWithoutFrom)
{
var p = Expression.Parameter(TypeHelper.GetElementType(source.Type), "x");
var predicate = Expression.Lambda(p.Equal(match), p);
var exp = Expression.Call(typeof(Queryable), "Any", new Type[] { p.Type }, source, predicate);
this.root = exp;
return this.Visit(exp);
}
else
{
ProjectionExpression projection = this.VisitSequence(source);
match = this.Visit(match);
Expression result = new InExpression(match, projection.Select);
if (isRoot)
{
return this.GetSingletonSequence(result, "SingleOrDefault");
}
return result;
}
}
protected override Expression VisitIn(InExpression inExpression)
{
Visit(inExpression.Expression);
sb.Append(" IN (");
if (inExpression.Select == null)
{
bool any = false;
foreach (var obj in inExpression.Values)
{
VisitConstant(Expression.Constant(obj));
sb.Append(",");
any = true;
}
if (any)
sb.Remove(sb.Length - 1, 1);
}
else
{
Visit(inExpression.Select);
}
sb.Append(" )");
return inExpression;
}
protected virtual bool CompareIn(InExpression a, InExpression b)
{
return this.Compare(a.Expression, b.Expression)
&& this.Compare(a.Select, b.Select)
&& this.CompareExpressionList(a.Values, b.Values);
}
protected override Expression VisitIn(InExpression @in)
{
this.VisitValue(@in.Expression);
sb.Append(" IN (");
if (@in.Select != null)
{
this.AppendNewLine(Indentation.Inner);
this.Visit(@in.Select);
this.AppendNewLine(Indentation.Same);
sb.Append(")");
this.Indent(Indentation.Outer);
}
else if (@in.Values != null)
{
for (int i = 0, n = @in.Values.Count; i < n; i++)
{
if (i > 0) sb.Append(", ");
this.VisitValue(@in.Values[i]);
}
sb.Append(")");
}
return @in;
}
public void Visit(InExpression x)
{
}
protected override Expression VisitIn(InExpression expression)
{
if (HasNoValues(expression) && HasXmlToCursorExpression(expression.Select)) {
_expressions.Add(expression);
}
return expression;
}
public EntityInExpression(InExpression inExpression)
{
Assert.NotNull(inExpression, "InExpression must not be null");
this.inExpression = inExpression;
}
private static bool HasNoValues(InExpression expression)
{
return expression.Values == null;
}
/// <summary> /// Visits the children of the in expression. /// </summary> /// <param name="inExpression"> The expression to visit. </param> /// <returns> The modified expression, if it or any subexpression was modified; otherwise, returns the original expression. </returns> protected abstract Expression VisitIn([NotNull] InExpression inExpression);
// don't count aggregates in subqueries
protected internal override Expression VisitIn(InExpression @in)
{
return base.VisitIn(@in);
}
