public static IWhereFragment SimpleArrayContains(ISerializer serializer, QueryModel queryModel, ContainsResultOperator contains)
{
var from = queryModel.MainFromClause.FromExpression;
var visitor = new FindMembers();
visitor.Visit(from);
var members = visitor.Members;
var constant = contains.Item as ConstantExpression;
if (constant != null)
{
var array = Array.CreateInstance(constant.Type, 1);
array.SetValue(constant.Value, 0);
var dict = new Dictionary<string, object>();
dict.Add(members.Last().Name, array);
members.Reverse().Skip(1).Each(m =>
{
dict = new Dictionary<string, object>() { {m.Name, dict} };
});
return new ContainmentWhereFragment(serializer, dict);
}
throw new NotSupportedException();
}
private bool TryHandleContains(SubQueryExpression subquery, ContainsResultOperator ro)
{
switch (subquery.QueryModel.MainFromClause.FromExpression)
{
case ConstantExpression expr:
if (!(expr.Value is IList list))
{
return(false);
}
CurrentExpression.Add("IN");
Visit(ro.Item);
var opList = new List <object> {
"[]"
};
opList.AddRange(list.Cast <object>());
CurrentExpression.Add(opList);
return(true);
case MemberExpression expr:
var last = _currentExpression;
CurrentExpression.Add("ARRAY_CONTAINS()");
Visit(expr);
Visit(ro.Item);
_currentExpression = last;
return(true);
}
return(false);
}
private void VisitContainsResultOperator(ContainsResultOperator containsResultOperator, Remotion.Linq.QueryModel queryModel, int index)
{
if (_query.IsSubQuery)
{
_visitor.Visit(containsResultOperator.Item);
QueryComponent item = _visitor.RetrieveComponent();
if (item is IExpression)
{
Filter filter = new Filter(new BinaryOperator(MethodNames.Equal, _mainFromComponent.About, (IExpression)item));
if (!_mainFromComponent.Elements.Contains(filter))
{
_mainFromComponent.Elements.Add(filter);
}
}
EntityConstrain constrain = new EntityConstrain(
new Identifier(_mainFromComponent.About.Name + "_p"),
new Identifier(_mainFromComponent.About.Name + "_o"),
containsResultOperator.Item);
if (!_mainFromComponent.Elements.Contains(constrain))
{
_mainFromComponent.Elements.Add(constrain);
}
Call call = new Call(MethodNames.Any);
call.Arguments.Add(_query);
_result = call;
}
else
{
throw new NotSupportedException(System.String.Format("Cannot perform 'Contains' operation on top level query."));
}
}
protected override Expression VisitSubQueryExpression(SubQueryExpression expression)
{
if (expression.QueryModel.MainFromClause.FromExpression.NodeType == ExpressionType.Constant && expression.QueryModel.ResultOperators.Count == 1)
{
var resultOperateor = expression.QueryModel.ResultOperators[0];
if (resultOperateor is ContainsResultOperator)
{
ContainsResultOperator containsOperateor = (ContainsResultOperator)resultOperateor;
VisitExpression(containsOperateor.Item);
VisitExpression(expression.QueryModel.MainFromClause.FromExpression);
if (isNot.HasValue && isNot.Value)
{
queryStack.Push(Query.NotIn(name, (BsonArray)value));
}
else
{
queryStack.Push(Query.In(name, (BsonArray)value));
}
isNot = null;
return(expression);
}
}
return(base.VisitSubQueryExpression(expression));
}
/// <summary>
/// Visits IEnumerable.Contains
/// </summary>
private void VisitContains(QueryModel subQueryModel, ContainsResultOperator contains)
{
ResultBuilder.Append('(');
var fromExpression = subQueryModel.MainFromClause.FromExpression;
var queryable = ExpressionWalker.GetCacheQueryable(fromExpression, false);
if (queryable != null)
{
Visit(contains.Item);
ResultBuilder.Append(" IN (");
if (_visitEntireSubQueryModel)
{
_modelVisitor.VisitQueryModel(subQueryModel, false, true);
}
else
{
_modelVisitor.VisitQueryModel(subQueryModel);
}
ResultBuilder.Append(')');
}
else
{
var inValues = ExpressionWalker.EvaluateEnumerableValues(fromExpression).ToArray();
var hasNulls = inValues.Any(o => o == null);
if (hasNulls)
{
ResultBuilder.Append('(');
}
Visit(contains.Item);
ResultBuilder.Append(" IN (");
AppendInParameters(inValues);
ResultBuilder.Append(')');
if (hasNulls)
{
ResultBuilder.Append(") OR ");
Visit(contains.Item);
ResultBuilder.Append(" IS NULL");
}
}
ResultBuilder.Append(')');
}
private static void FlattenSubQuery(SubQueryExpression subQueryExpression, QueryModel queryModel)
{
// we can not flattern subquery if outer query has body clauses.
var subQueryModel = subQueryExpression.QueryModel;
var subQueryMainFromClause = subQueryModel.MainFromClause;
if (queryModel.BodyClauses.Count == 0)
{
foreach (var resultOperator in subQueryModel.ResultOperators)
{
queryModel.ResultOperators.Add(resultOperator);
}
foreach (var bodyClause in subQueryModel.BodyClauses)
{
queryModel.BodyClauses.Add(bodyClause);
}
}
else
{
var cro = new ContainsResultOperator(new QuerySourceReferenceExpression(subQueryMainFromClause));
var newSubQueryModel = subQueryModel.Clone();
newSubQueryModel.ResultOperators.Add(cro);
newSubQueryModel.ResultTypeOverride = typeof(bool);
var where = new WhereClause(new SubQueryExpression(newSubQueryModel));
queryModel.BodyClauses.Add(where);
if (!queryModel.BodyClauses.OfType <OrderByClause>().Any())
{
var orderByClauses = subQueryModel.BodyClauses.OfType <OrderByClause>();
foreach (var orderByClause in orderByClauses)
{
queryModel.BodyClauses.Add(orderByClause);
}
}
}
var visitor1 = new PagingRewriterSelectClauseVisitor();
queryModel.SelectClause.TransformExpressions(visitor1.Swap);
// Point all query source references to the outer from clause
var visitor2 = new SwapQuerySourceVisitor(queryModel.MainFromClause, subQueryMainFromClause);
queryModel.TransformExpressions(visitor2.Swap);
// Replace the outer query source
queryModel.MainFromClause = subQueryMainFromClause;
}
public void TransformExpressions()
{
var oldExpression = ExpressionHelper.CreateExpression();
var newExpression = ExpressionHelper.CreateExpression();
var resultOperator = new ContainsResultOperator(oldExpression);
resultOperator.TransformExpressions(ex =>
{
Assert.That(ex, Is.SameAs(oldExpression));
return(newExpression);
});
Assert.That(resultOperator.Item, Is.SameAs(newExpression));
}
private static Expression HandleContains(
EntityQueryModelVisitor entityQueryModelVisitor,
ContainsResultOperator containsResultOperator,
QueryModel queryModel)
{
var item = entityQueryModelVisitor
.ReplaceClauseReferences(
containsResultOperator.Item,
queryModel.MainFromClause);
return(CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.Contains
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression,
item));
}
private static void FlattenSubQuery(SubQueryExpression subQueryExpression, QueryModel queryModel)
{
// we can not flattern subquery if outer query has body clauses.
var subQueryModel = subQueryExpression.QueryModel;
var subQueryMainFromClause = subQueryModel.MainFromClause;
if (queryModel.BodyClauses.Count == 0)
{
foreach (var resultOperator in subQueryModel.ResultOperators)
queryModel.ResultOperators.Add(resultOperator);
foreach (var bodyClause in subQueryModel.BodyClauses)
queryModel.BodyClauses.Add(bodyClause);
}
else
{
var cro = new ContainsResultOperator(new QuerySourceReferenceExpression(subQueryMainFromClause));
var newSubQueryModel = subQueryModel.Clone();
newSubQueryModel.ResultOperators.Add(cro);
newSubQueryModel.ResultTypeOverride = typeof (bool);
var where = new WhereClause(new SubQueryExpression(newSubQueryModel));
queryModel.BodyClauses.Add(where);
if (!queryModel.BodyClauses.OfType<OrderByClause>().Any())
{
var orderByClauses = subQueryModel.BodyClauses.OfType<OrderByClause>();
foreach (var orderByClause in orderByClauses)
queryModel.BodyClauses.Add(orderByClause);
}
}
var visitor1 = new PagingRewriterSelectClauseVisitor();
queryModel.SelectClause.TransformExpressions(visitor1.Swap);
// Point all query source references to the outer from clause
var visitor2 = new SwapQuerySourceVisitor(queryModel.MainFromClause, subQueryMainFromClause);
queryModel.TransformExpressions(visitor2.Swap);
// Replace the outer query source
queryModel.MainFromClause = subQueryMainFromClause;
}
public void HandleResultOperator ()
{
var itemExpression = Expression.Constant (new Cook ());
var resultOperator = new ContainsResultOperator (itemExpression);
var sqlStatement = _sqlStatementBuilder.GetSqlStatement ();
var preparedExpression = Expression.Constant (new Cook (), typeof (Cook));
_stageMock.Expect (mock => mock.PrepareResultOperatorItemExpression (itemExpression, _context)).Return (preparedExpression);
_stageMock.Replay ();
_handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations ();
Assert.That (_sqlStatementBuilder.DataInfo, Is.TypeOf (typeof (StreamedScalarValueInfo)));
Assert.That (((StreamedScalarValueInfo) _sqlStatementBuilder.DataInfo).DataType, Is.EqualTo (typeof (Boolean)));
var expectedExpression = new SqlInExpression (preparedExpression, new SqlSubStatementExpression (sqlStatement));
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, _sqlStatementBuilder.SelectProjection);
}
private void VisitContainsResultOperator(ContainsResultOperator containsResultOperator, Remotion.Linq.QueryModel queryModel, int index)
{
Call call = new Call(MethodNames.In);
System.Linq.Expressions.Expression expression = _visitor.TransformUnaryExpression(containsResultOperator.Item);
Identifier targetIdentifier = Identifier.Current;
if (expression is System.Linq.Expressions.MemberExpression)
{
System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)expression;
_visitor.Visit(expression);
QueryComponent component = _visitor.RetrieveComponent();
if (component is Identifier)
{
targetIdentifier = (Identifier)component;
}
}
call.Arguments.Add(targetIdentifier);
_result = call;
}
public void HandleResultOperator()
{
var itemExpression = Expression.Constant(new Cook());
var resultOperator = new ContainsResultOperator(itemExpression);
var sqlStatement = _sqlStatementBuilder.GetSqlStatement();
var preparedExpression = Expression.Constant(new Cook(), typeof(Cook));
_stageMock.Expect(mock => mock.PrepareResultOperatorItemExpression(itemExpression, _context)).Return(preparedExpression);
_stageMock.Replay();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedScalarValueInfo)));
Assert.That(((StreamedScalarValueInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(Boolean)));
var expectedExpression = new SqlInExpression(preparedExpression, new SqlSubStatementExpression(sqlStatement));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, _sqlStatementBuilder.SelectProjection);
}
private void VisitContainsResultOperator(ContainsResultOperator containsResultOperator, Remotion.Linq.QueryModel queryModel, int index)
{
if (_query.IsSubQuery)
{
_visitor.VisitExpression(containsResultOperator.Item);
QueryComponent item = _visitor.RetrieveComponent();
if (item is IExpression)
{
Filter filter = new Filter(new BinaryOperator(MethodNames.Equal, _mainFromComponent.About, (IExpression)item));
if (!_mainFromComponent.Elements.Contains(filter))
{
_mainFromComponent.Elements.Add(filter);
}
}
EntityConstrain constrain = new EntityConstrain(
new Identifier(_mainFromComponent.About.Name + "_p"),
new Identifier(_mainFromComponent.About.Name + "_o"),
containsResultOperator.Item);
if (!_mainFromComponent.Elements.Contains(constrain))
{
_mainFromComponent.Elements.Add(constrain);
}
Call call = new Call(MethodNames.Any);
call.Arguments.Add(_query);
_result = call;
}
else
{
throw new NotSupportedException(System.String.Format("Cannot perform 'Contains' operation on top level query."));
}
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
resultOptionType = resultOptionType ?? queryModel.SelectClause.Selector.Type;
if (resultOperator is CastResultOperator)
{
CastResultOperator castResultOperator = (CastResultOperator)resultOperator;
Type castType = castResultOperator.CastItemType;
MethodInfo cast = GetMethod("Cast", expression.Type).MakeGenericMethod(castType);
resultOptionType = castType;
expression = Expression.Call(cast, expression);
return;
}
if (resultOperator is AllResultOperator)
{
AllResultOperator allResultOperator = (AllResultOperator)resultOperator;
ParameterExpression parameterExpression = Expression.Parameter(selectorType, "p");
Expression predicateUpdate = UpdateExpressionVisitor.Update(allResultOperator.Predicate, new[] { parameterExpression }, dbContext, queryContext);
Expression allLamda = Expression.Lambda(predicateUpdate, parameterExpression);
MethodInfo all = GetMethod("All", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(all, new[] { expression, allLamda });
return;
}
if (resultOperator is FirstResultOperator)
{
FirstResultOperator firstResultOperator = (FirstResultOperator)resultOperator;
if (firstResultOperator.ReturnDefaultWhenEmpty)
{
MethodInfo firstOrDefault = GetMethod("FirstOrDefault", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(firstOrDefault, new[] { expression });
}
else
{
MethodInfo first = GetMethod("First", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(first, new[] { expression });
}
return;
}
if (resultOperator is SingleResultOperator)
{
SingleResultOperator singleResultOperator = (SingleResultOperator)resultOperator;
if (singleResultOperator.ReturnDefaultWhenEmpty)
{
MethodInfo firstOrDefault = GetMethod("SingleOrDefault", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(firstOrDefault, new[] { expression });
}
else
{
MethodInfo first = GetMethod("Single", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(first, new[] { expression });
}
return;
}
if (resultOperator is AnyResultOperator)
{
MethodInfo any = GetMethod("Any", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(any, new[] { expression });
return;
}
if (resultOperator is TrackingResultOperator)
{
MethodInfo asNoTracking = typeof(EntityFrameworkQueryableExtensions).GetMethod("AsNoTracking").MakeGenericMethod(selectorType);
expression = Expression.Call(asNoTracking, new[] { expression });
return;
}
if (resultOperator is CountResultOperator)
{
MethodInfo count = GetMethod("Count", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(count, new[] { expression });
return;
}
if (resultOperator is AverageResultOperator)
{
MethodInfo average = GetAgregateMethod("Average", expression.Type, selectorType);
expression = Expression.Call(average, new[] { expression });
return;
}
if (resultOperator is ContainsResultOperator)
{
ContainsResultOperator containsResultOperator = (ContainsResultOperator)resultOperator;
Expression valExp;
object value;
ParameterExpression paramExp = containsResultOperator.Item as ParameterExpression;
if (paramExp != null &&
queryContext.ParameterValues.TryGetValue(paramExp.Name, out value))
{
valExp = Expression.Constant(value);
}
else
{
valExp = containsResultOperator.Item;
}
if (containsResultOperator.Item is SubQueryExpression)
{
SubQueryExpression subQueryExpression = (SubQueryExpression)containsResultOperator.Item;
QueryModelVisitor queryModelVisitor = new QueryModelVisitor(dbContext, queryContext);
queryModelVisitor.VisitQueryModel(subQueryExpression.QueryModel);
valExp = queryModelVisitor.expression;
}
MethodInfo contains = GetMethod("Contains", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(contains, new[] { expression, valExp });
return;
}
if (resultOperator is DefaultIfEmptyResultOperator)
{
DefaultIfEmptyResultOperator defaultIfEmptyResultOperator = (DefaultIfEmptyResultOperator)resultOperator;
MethodInfo defaultIfEmpty;
if (defaultIfEmptyResultOperator.OptionalDefaultValue != null)
{
defaultIfEmpty = GetMethod("DefaultIfEmpty", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(defaultIfEmpty, new[] { expression, defaultIfEmptyResultOperator.OptionalDefaultValue });
}
defaultIfEmpty = GetMethod("DefaultIfEmpty", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(defaultIfEmpty, expression);
return;
}
if (resultOperator is DistinctResultOperator)
{
MethodInfo distinct = GetMethod("Distinct", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(distinct, expression);
return;
}
if (resultOperator is GroupResultOperator)
{
GroupResultOperator groupResultOperator = (GroupResultOperator)resultOperator;
Type keySelectorType = GetTypeParameter(groupResultOperator.KeySelector);
ParameterExpression keyExpressionParam = Expression.Parameter(keySelectorType, "p");
Expression keyExpression = UpdateExpressionVisitor.Update(groupResultOperator.KeySelector, new[] { keyExpressionParam }, dbContext, queryContext);
LambdaExpression keyLambdaExpression = Expression.Lambda(keyExpression, keyExpressionParam);
Type elementSelectorType = GetTypeParameter(groupResultOperator.ElementSelector);
ParameterExpression ElementExpressionParam = Expression.Parameter(elementSelectorType, "p");
Expression ElementExpression = UpdateExpressionVisitor.Update(groupResultOperator.ElementSelector, new[] { ElementExpressionParam }, dbContext, queryContext);
LambdaExpression ElementLambdaExpression = Expression.Lambda(ElementExpression, ElementExpressionParam);
Type tSource = queryModel.MainFromClause.ItemType;
Type tKey = keyExpression.Type;
Type tElement = ElementExpression.Type;
Type tResult = queryModel.ResultTypeOverride;
MethodInfo groupBy = GetMethods("GroupBy", expression.Type, 2).Where(p => p.GetParameters()[2].Name == "elementSelector").Single().
MakeGenericMethod(tSource, tKey, tElement);
expression = Expression.Call(groupBy, new[] { expression, keyLambdaExpression, ElementLambdaExpression });
return;
}
if (resultOperator is LastResultOperator)
{
LastResultOperator lastResultOperator = (LastResultOperator)resultOperator;
if (lastResultOperator.ReturnDefaultWhenEmpty)
{
MethodInfo lastOrDefault = GetMethod("LastOrDefault", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(lastOrDefault, new[] { expression });
}
else
{
MethodInfo last = GetMethod("Last", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(last, new[] { expression });
}
return;
}
if (resultOperator is LongCountResultOperator)
{
MethodInfo longCount = GetMethod("LongCount", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(longCount, new[] { expression });
return;
}
if (resultOperator is MaxResultOperator)
{
MethodInfo max = GetMethod("Max", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(max, expression);
return;
}
if (resultOperator is MinResultOperator)
{
MethodInfo min = GetMethod("Min", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(min, expression);
return;
}
if (resultOperator is SumResultOperator)
{
MethodInfo sum = GetAgregateMethod("Sum", expression.Type, selectorType);
expression = Expression.Call(sum, expression);
return;
}
if (resultOperator is SkipResultOperator)
{
SkipResultOperator skipResultOperator = (SkipResultOperator)resultOperator;
Expression expVal;
object value;
ParameterExpression paramExp = skipResultOperator.Count as ParameterExpression;
if (paramExp != null &&
queryContext.ParameterValues.TryGetValue(paramExp.Name, out value))
{
expVal = Expression.Constant(value);
}
else
{
expVal = skipResultOperator.Count;
}
MethodInfo skip = GetMethod("Skip", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(skip, new[] { expression, expVal });
return;
}
if (resultOperator is TakeResultOperator)
{
TakeResultOperator takeResultOperator = (TakeResultOperator)resultOperator;
Expression expVal;
object value;
ParameterExpression paramExp = takeResultOperator.Count as ParameterExpression;
if (paramExp != null &&
queryContext.ParameterValues.TryGetValue(paramExp.Name, out value))
{
expVal = Expression.Constant(value);
}
else
{
expVal = takeResultOperator.Count;
}
MethodInfo take = GetMethod("Take", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(take, new[] { expression, expVal });
return;
}
if (resultOperator is IncludeResultOperator)
{
IncludeResultOperator includeResultOperator = (IncludeResultOperator)resultOperator;
Expression includeExpression = includeResultOperator.NavigationPropertyPath;
Type paramExpressionType = null;
ParameterExpression parameterExpression = null;
if (includeExpression is MemberExpression)
{
MemberExpression memberExpression = (MemberExpression)includeExpression;
paramExpressionType = memberExpression.Expression.Type;
parameterExpression = Expression.Parameter(paramExpressionType, "p");
includeExpression = Expression.Property(parameterExpression, memberExpression.Member.Name);
}
else
{
paramExpressionType = GetTypeParameter(includeExpression);
parameterExpression = Expression.Parameter(paramExpressionType, "p");
}
Expression updateOuterExpression = UpdateExpressionVisitor.Update(includeExpression, new[] { parameterExpression }, dbContext, queryContext);
LambdaExpression lambdaIncludeExpression = Expression.Lambda(updateOuterExpression, parameterExpression);
MethodInfo include = typeof(EntityFrameworkQueryableExtensions).GetMethods().First(m => m.Name == "Include").MakeGenericMethod(selectorType, updateOuterExpression.Type);
expression = Expression.Call(include, new[] { expression, lambdaIncludeExpression });
if (includeResultOperator.ChainedNavigationProperties != null)
{
foreach (PropertyInfo propertyInfo in includeResultOperator.ChainedNavigationProperties)
{
Type propertyType = propertyInfo.PropertyType;
Type argument = expression.Type.GetGenericArguments().Last();
MethodInfo thenInclude;
Type realType;
if (typeof(IEnumerable).IsAssignableFrom(argument))
{
realType = argument.GetGenericArguments().First();
thenInclude = ThenIncludeCollection.MakeGenericMethod(includeResultOperator.QuerySource.ItemType, realType, propertyType);
}
else
{
realType = argument;
thenInclude = ThenIncludeProperty.MakeGenericMethod(includeResultOperator.QuerySource.ItemType, realType, propertyType);
}
ParameterExpression parameterThenIncludeExpression = Expression.Parameter(realType, "p");
MemberExpression property = Expression.Property(parameterThenIncludeExpression, propertyInfo);
LambdaExpression lambdaThenIncludeExpression = Expression.Lambda(property, parameterThenIncludeExpression);
expression = Expression.Call(thenInclude, new[] { expression, lambdaThenIncludeExpression });
}
}
return;
}
if (resultOperator is OfTypeResultOperator)
{
OfTypeResultOperator ofTypeResultOperator = (OfTypeResultOperator)resultOperator;
selectorType = ofTypeResultOperator.SearchedItemType;
var miOfType = GetMethod("OfType", expression.Type).MakeGenericMethod(ofTypeResultOperator.SearchedItemType);
expression = Expression.Call(miOfType, new[] { expression });
return;
}
throw new NotSupportedException();
}
public void SetUp()
{
_resultOperator = new ContainsResultOperator(Expression.Constant(2));
}
public void GetConstantItem_NoConstantExpression()
{
var resultOperator = new ContainsResultOperator(new QuerySourceReferenceExpression(ExpressionHelper.CreateMainFromClause_Int()));
resultOperator.GetConstantItem <object> ();
}
private static Expression HandleContains(
EntityQueryModelVisitor entityQueryModelVisitor,
ContainsResultOperator containsResultOperator,
QueryModel queryModel)
{
var item = entityQueryModelVisitor
.ReplaceClauseReferences(
containsResultOperator.Item,
queryModel.MainFromClause);
return CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.Contains
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression,
item);
}
private void VisitContainsResultOperator(ContainsResultOperator containsResultOperator, Remotion.Linq.QueryModel queryModel, int index)
{
Call call = new Call(MethodNames.In);
call.Arguments.Add(Identifier.Current);
_result = call;
}
public void SetUp ()
{
_resultOperator = new ContainsResultOperator (Expression.Constant (2));
}
public void TransformExpressions ()
{
var oldExpression = ExpressionHelper.CreateExpression ();
var newExpression = ExpressionHelper.CreateExpression ();
var resultOperator = new ContainsResultOperator (oldExpression);
resultOperator.TransformExpressions (ex =>
{
Assert.That (ex, Is.SameAs (oldExpression));
return newExpression;
});
Assert.That (resultOperator.Item, Is.SameAs (newExpression));
}
public void GetConstantItem_NoConstantExpression ()
{
var resultOperator = new ContainsResultOperator (new QuerySourceReferenceExpression (ExpressionHelper.CreateMainFromClause_Int ()));
resultOperator.GetConstantItem<object> ();
}
