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