public void IntegrationTest_WithExpressionNodes() { var query = from a in ExpressionHelper.CreateQueryable <Cook> () from b in ExpressionHelper.CreateQueryable <Cook>() where a.ID > 5 select a.ID; var nodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry(); nodeTypeRegistry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); nodeTypeRegistry.Register(SelectManyExpressionNode.GetSupportedMethods(), typeof(SelectManyExpressionNode)); nodeTypeRegistry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode)); var selectNode = (SelectExpressionNode) new ExpressionTreeParser(nodeTypeRegistry, new NullExpressionTreeProcessor()).ParseTree(query.Expression); var clauseGenerationContext = new ClauseGenerationContext(new MethodInfoBasedNodeTypeRegistry()); var selectManyNode = (SelectManyExpressionNode)selectNode.Source.Source; var mainSourceExpressionNode = (MainSourceExpressionNode)selectManyNode.Source; var queryModel = mainSourceExpressionNode.Apply(null, clauseGenerationContext); var mainFromClause = queryModel.MainFromClause; selectManyNode.Apply(queryModel, clauseGenerationContext); // only to add the clause to the mapping var selectProjection = selectNode.GetResolvedSelector(clauseGenerationContext); // new ( a = IR (a), b = IR (b) ).a.ID var result = TransparentIdentifierRemovingExpressionVisitor.ReplaceTransparentIdentifiers(selectProjection); // IR(a).ID Assert.That(result, Is.InstanceOf(typeof(MemberExpression))); Expression innerExpression = ((MemberExpression)result).Expression; Assert.That(innerExpression, Is.InstanceOf(typeof(QuerySourceReferenceExpression))); Assert.That(((QuerySourceReferenceExpression)innerExpression).ReferencedQuerySource, Is.SameAs(mainFromClause)); }
public void Test_WithNotRegistered_ReturnsFalse() { var registry = _registry; var result = registry.IsRegistered(SelectExpressionNode.GetSupportedMethods().First()); Assert.That(result, Is.False); }
public void Test_WithMethodInfo() { Assert.That(_registry.RegisteredMethodInfoCount, Is.EqualTo(0)); _registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); Assert.That(_registry.RegisteredMethodInfoCount, Is.EqualTo(2)); }
public void Test_WithMethodInfo() { _registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); var type = _registry.GetNodeType(SelectExpressionNode.GetSupportedMethods().First()); Assert.That(type, Is.SameAs(typeof(SelectExpressionNode))); }
public override void SetUp() { base.SetUp(); var selector = ExpressionHelper.CreateLambdaExpression <int, bool> (i => i > 5); _node = new SelectExpressionNode(CreateParseInfo(), selector); }
public void Test_WithRegistered_ReturnsTrue() { var registry = _registry; registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); var result = registry.IsRegistered(SelectExpressionNode.GetSupportedMethods().First()); Assert.That(result, Is.True); }
public void Test_ClosedGenericMethod() { _registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); var closedGenericMethodCallExpression = (MethodCallExpression)ExpressionHelper.MakeExpression <IQueryable <int>, IQueryable <int> > (q => q.Select(i => i + 1)); var type = _registry.GetNodeType(closedGenericMethodCallExpression.Method); Assert.That(type, Is.SameAs(typeof(SelectExpressionNode))); }
public void GetResolvedSelector() { var selector = ExpressionHelper.CreateLambdaExpression <int, bool> (i => i > 5); var node = new SelectExpressionNode(CreateParseInfo(), selector); var expectedResult = Expression.MakeBinary(ExpressionType.GreaterThan, SourceReference, Expression.Constant(5)); var result = node.GetResolvedSelector(ClauseGenerationContext); ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
public void GetSupportedMethods() { Assert.That( SelectExpressionNode.GetSupportedMethods(), Is.EquivalentTo( new[] { GetGenericMethodDefinition(() => Queryable.Select <object, object> (null, o => null)), GetGenericMethodDefinition(() => Enumerable.Select <object, object> (null, o => null)) })); }
public void Test_WithClosedGenericMethod_ReturnsTrue() { var registry = _registry; registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); var closedGenericMethodCallExpression = (MethodCallExpression)ExpressionHelper.MakeExpression <IQueryable <int>, IQueryable <int> > (q => q.Select(i => i + 1)); var result = registry.IsRegistered(closedGenericMethodCallExpression.Method); Assert.That(result, Is.True); }
public void Test_WithMultipleNodes() { _registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); _registry.Register(SumExpressionNode.GetSupportedMethods(), typeof(SumExpressionNode)); var type1 = _registry.GetNodeType(SelectExpressionNode.GetSupportedMethods().First()); var type2 = _registry.GetNodeType(SumExpressionNode.GetSupportedMethods().First()); var type3 = _registry.GetNodeType(SumExpressionNode.GetSupportedMethods().Skip(1).First()); Assert.That(type1, Is.SameAs(typeof(SelectExpressionNode))); Assert.That(type2, Is.SameAs(typeof(SumExpressionNode))); Assert.That(type3, Is.SameAs(typeof(SumExpressionNode))); }
public void Apply_WrapsQueryModel_AndEnsuresResolveWorksCorrectly() { var newQueryModel = _nodeWithResultOperatorSource.Apply(_queryModelWithResultOperator, ClauseGenerationContext); Expression <Func <int, string> > selector = i => i.ToString(); var selectCall = (MethodCallExpression)ExpressionHelper.MakeExpression <IQueryable <int>, IQueryable <string> > (q => q.Select(selector)); var selectExpressionNode = new SelectExpressionNode(new MethodCallExpressionParseInfo("y", _nodeWithResultOperatorSource, selectCall), selector); selectExpressionNode.Apply(newQueryModel, ClauseGenerationContext); var newSelector = (MethodCallExpression)newQueryModel.SelectClause.Selector; Assert.That(((QuerySourceReferenceExpression)newSelector.Object).ReferencedQuerySource, Is.SameAs(newQueryModel.MainFromClause)); }
public void SetUp() { _methodInfoBasedNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry(); _methodInfoBasedNodeTypeRegistry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode)); _methodInfoBasedNodeTypeRegistry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); _methodInfoBasedNodeTypeRegistry.Register(TakeExpressionNode.GetSupportedMethods(), typeof(TakeExpressionNode)); _methodInfoBasedNodeTypeRegistry.Register(CountExpressionNode.GetSupportedMethods(), typeof(CountExpressionNode)); _methodInfoBasedNodeTypeRegistry.Register(JoinExpressionNode.GetSupportedMethods(), typeof(JoinExpressionNode)); _parser = new MethodCallExpressionParser(_methodInfoBasedNodeTypeRegistry); _source = ExpressionNodeObjectMother.CreateMainSource(); }
public void Resolve_ReplacesParameter_WithProjection() { var node = new SelectExpressionNode(CreateParseInfo(), ExpressionHelper.CreateLambdaExpression <int, int> (j => j * j)); var expression = ExpressionHelper.CreateLambdaExpression <int, bool> (i => i > 5); var result = node.Resolve(expression.Parameters[0], expression.Body, ClauseGenerationContext); var expectedResult = Expression.MakeBinary( ExpressionType.GreaterThan, Expression.MakeBinary(ExpressionType.Multiply, SourceReference, SourceReference), Expression.Constant(5)); ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
public void CreateQueryParser_HasDefaultNodesAndSteps() { var selectMethod = SelectExpressionNode.GetSupportedMethods().First(); var queryParser = (QueryParser)_factory.CreateQueryParser(); Assert.That(queryParser.NodeTypeProvider, Is.TypeOf(typeof(CompoundNodeTypeProvider))); Assert.That(((CompoundNodeTypeProvider)queryParser.NodeTypeProvider).InnerProviders[1], Is.TypeOf(typeof(MethodInfoBasedNodeTypeRegistry))); Assert.That(((CompoundNodeTypeProvider)queryParser.NodeTypeProvider).InnerProviders[2], Is.TypeOf(typeof(MethodNameBasedNodeTypeRegistry))); Assert.That(queryParser.NodeTypeProvider.GetNodeType(selectMethod), Is.SameAs(typeof(SelectExpressionNode))); var processingSteps = ((CompoundExpressionTreeProcessor)queryParser.Processor).InnerProcessors; Assert.That(processingSteps.Count, Is.EqualTo(ExpressionTreeParser.CreateDefaultProcessor(ExpressionTransformerRegistry.CreateDefault()).InnerProcessors.Count)); }
public void SetUp() { _methodInfoBasedNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry(); _methodInfoBasedNodeTypeRegistry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode)); _methodInfoBasedNodeTypeRegistry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); _methodInfoBasedNodeTypeRegistry.Register(TakeExpressionNode.GetSupportedMethods(), typeof(TakeExpressionNode)); _methodInfoBasedNodeTypeRegistry.Register(CountExpressionNode.GetSupportedMethods(), typeof(CountExpressionNode)); _methodInfoBasedNodeTypeRegistry.Register(ContainsExpressionNode.GetSupportedMethods(), typeof(ContainsExpressionNode)); _expressionTreeParser = new ExpressionTreeParser( _methodInfoBasedNodeTypeRegistry, new PartialEvaluatingExpressionTreeProcessor(new TestEvaluatableExpressionFilter())); _intSource = new[] { 1, 2, 3 }.AsQueryable(); }
public void Parse_WithSubQuery_UsesNodeTypeRegistry() { var emptyNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry(); emptyNodeTypeRegistry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); var parser = new MethodCallExpressionParser(emptyNodeTypeRegistry); var expression = (MethodCallExpression)ExpressionHelper.MakeExpression <IQueryable <Cook>, IQueryable <int> > ( q => q.Select(s => s.Assistants.Count())); var result = parser.Parse("t", _source, expression.Arguments.Skip(1), expression); Assert.That(result, Is.InstanceOf(typeof(SelectExpressionNode))); Assert.That(((SelectExpressionNode)result).Selector, Is.Not.TypeOf(typeof(SubQueryExpression)), "The given nodeTypeRegistry does not know any query methods, so no SubQueryExpression is generated."); }
/// <summary> /// Creates a <see cref="MethodInfoBasedNodeTypeRegistry"/> and registers all relevant <see cref="IExpressionNode"/> implementations in the <b>Remotion.Linq</b> assembly. /// </summary> /// <returns> /// A <see cref="MethodInfoBasedNodeTypeRegistry"/> with all <see cref="IExpressionNode"/> types in the <b>Remotion.Linq</b> assembly registered. /// </returns> public static MethodInfoBasedNodeTypeRegistry CreateFromRelinqAssembly() { var registry = new MethodInfoBasedNodeTypeRegistry(); registry.Register(AggregateExpressionNode.GetSupportedMethods(), typeof(AggregateExpressionNode)); registry.Register(AggregateFromSeedExpressionNode.GetSupportedMethods(), typeof(AggregateFromSeedExpressionNode)); registry.Register(AllExpressionNode.GetSupportedMethods(), typeof(AllExpressionNode)); registry.Register(AnyExpressionNode.GetSupportedMethods(), typeof(AnyExpressionNode)); registry.Register(AsQueryableExpressionNode.GetSupportedMethods(), typeof(AsQueryableExpressionNode)); registry.Register(AverageExpressionNode.GetSupportedMethods(), typeof(AverageExpressionNode)); registry.Register(CastExpressionNode.GetSupportedMethods(), typeof(CastExpressionNode)); registry.Register(ConcatExpressionNode.GetSupportedMethods(), typeof(ConcatExpressionNode)); registry.Register(ContainsExpressionNode.GetSupportedMethods(), typeof(ContainsExpressionNode)); registry.Register(CountExpressionNode.GetSupportedMethods(), typeof(CountExpressionNode)); registry.Register(DefaultIfEmptyExpressionNode.GetSupportedMethods(), typeof(DefaultIfEmptyExpressionNode)); registry.Register(DistinctExpressionNode.GetSupportedMethods(), typeof(DistinctExpressionNode)); registry.Register(ExceptExpressionNode.GetSupportedMethods(), typeof(ExceptExpressionNode)); registry.Register(FirstExpressionNode.GetSupportedMethods(), typeof(FirstExpressionNode)); registry.Register(GroupByExpressionNode.GetSupportedMethods(), typeof(GroupByExpressionNode)); registry.Register(GroupByWithResultSelectorExpressionNode.GetSupportedMethods(), typeof(GroupByWithResultSelectorExpressionNode)); registry.Register(GroupJoinExpressionNode.GetSupportedMethods(), typeof(GroupJoinExpressionNode)); registry.Register(IntersectExpressionNode.GetSupportedMethods(), typeof(IntersectExpressionNode)); registry.Register(JoinExpressionNode.GetSupportedMethods(), typeof(JoinExpressionNode)); registry.Register(LastExpressionNode.GetSupportedMethods(), typeof(LastExpressionNode)); registry.Register(LongCountExpressionNode.GetSupportedMethods(), typeof(LongCountExpressionNode)); registry.Register(MaxExpressionNode.GetSupportedMethods(), typeof(MaxExpressionNode)); registry.Register(MinExpressionNode.GetSupportedMethods(), typeof(MinExpressionNode)); registry.Register(OfTypeExpressionNode.GetSupportedMethods(), typeof(OfTypeExpressionNode)); registry.Register(OrderByDescendingExpressionNode.GetSupportedMethods(), typeof(OrderByDescendingExpressionNode)); registry.Register(OrderByExpressionNode.GetSupportedMethods(), typeof(OrderByExpressionNode)); registry.Register(ReverseExpressionNode.GetSupportedMethods(), typeof(ReverseExpressionNode)); registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode)); registry.Register(SelectManyExpressionNode.GetSupportedMethods(), typeof(SelectManyExpressionNode)); registry.Register(SingleExpressionNode.GetSupportedMethods(), typeof(SingleExpressionNode)); registry.Register(SkipExpressionNode.GetSupportedMethods(), typeof(SkipExpressionNode)); registry.Register(SumExpressionNode.GetSupportedMethods(), typeof(SumExpressionNode)); registry.Register(TakeExpressionNode.GetSupportedMethods(), typeof(TakeExpressionNode)); registry.Register(ThenByDescendingExpressionNode.GetSupportedMethods(), typeof(ThenByDescendingExpressionNode)); registry.Register(ThenByExpressionNode.GetSupportedMethods(), typeof(ThenByExpressionNode)); registry.Register(UnionExpressionNode.GetSupportedMethods(), typeof(UnionExpressionNode)); registry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode)); return(registry); }
public void Test_UnknownMethod() { var result = _registry.GetNodeType(SelectExpressionNode.GetSupportedMethods().First()); Assert.That(result, Is.Null); }