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