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 override void SetUp()
{
base.SetUp();
var predicate = ExpressionHelper.CreateLambdaExpression <int, bool> (i => i > 5);
_node = new WhereExpressionNode(CreateParseInfo(), predicate);
}
public void Test_SameMethodTwice_OverridesPreviousNodeType()
{
var registry = _registry;
registry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode));
registry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode));
var type = registry.GetNodeType(WhereExpressionNode.GetSupportedMethods().First());
Assert.That(type, Is.SameAs(typeof(WhereExpressionNode)));
}
public void GetResolvedPredicate()
{
var predicate = ExpressionHelper.CreateLambdaExpression <int, bool> (i => i > 5);
var node = new WhereExpressionNode(CreateParseInfo(), predicate);
var expectedResult = Expression.MakeBinary(ExpressionType.GreaterThan, SourceReference, Expression.Constant(5));
var result = node.GetResolvedPredicate(ClauseGenerationContext);
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void GetSupportedMethods()
{
Assert.That(
WhereExpressionNode.GetSupportedMethods(),
Is.EquivalentTo(
new[]
{
GetGenericMethodDefinition(() => Queryable.Where <object> (null, o => true)),
GetGenericMethodDefinition(() => Enumerable.Where <object> (null, o => true))
}));
}
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_PassesExpressionToSource()
{
var sourceMock = MockRepository.GenerateMock <IExpressionNode>();
var predicate = ExpressionHelper.CreateLambdaExpression <int, bool> (i => i > 5);
var node = new WhereExpressionNode(CreateParseInfo(sourceMock), predicate);
var expression = ExpressionHelper.CreateLambdaExpression();
var parameter = ExpressionHelper.CreateParameterExpression();
var expectedResult = ExpressionHelper.CreateExpression();
sourceMock.Expect(mock => mock.Resolve(parameter, expression, ClauseGenerationContext)).Return(expectedResult);
var result = node.Resolve(parameter, expression, ClauseGenerationContext);
sourceMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(expectedResult));
}
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();
}
/// <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 Init(ParsingContext context, ParseTreeNode parseNode)
{
_toBeDeletedAttributes = new List <String>();
_typeName = parseNode.ChildNodes[1].Token.ValueString;
if (HasChildNodes(parseNode.ChildNodes[3]))
{
foreach (var _ParseTreeNode in parseNode.ChildNodes[3].ChildNodes[0].ChildNodes)
{
_toBeDeletedAttributes.Add(_ParseTreeNode.ChildNodes[0].Token.ValueString);
}
}
#region whereClauseOpt
if (parseNode.ChildNodes[4].ChildNodes != null && parseNode.ChildNodes[4].ChildNodes.Count != 0)
{
WhereExpressionNode tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode;
_WhereExpression = tempWhereNode.BinaryExpressionDefinition;
}
#endregion
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
#region Data
TypeList = new List <TypeReferenceDefinition>();
GroupByIDs = new List <IDChainDefinition>();
SelectedElements = new List <Tuple <AExpressionDefinition, string, SelectValueAssignment> >();
Limit = null;
Offset = null;
WhereExpressionDefinition = null;
ResolutionDepth = -1;
#endregion
#region TypeList
foreach (ParseTreeNode aNode in parseNode.ChildNodes[1].ChildNodes)
{
ATypeNode aType = (ATypeNode)aNode.AstNode;
// use the overrides equals to check duplicated references
if (!TypeList.Contains(aType.ReferenceAndType))
{
TypeList.Add(aType.ReferenceAndType);
}
else
{
throw new DuplicateReferenceOccurrenceException(aType.ReferenceAndType.TypeName);
}
}
#endregion
#region selList
foreach (ParseTreeNode aNode in parseNode.ChildNodes[3].ChildNodes)
{
SelectionListElementNode aColumnItemNode = (SelectionListElementNode)aNode.AstNode;
String typeName = null;
if (aColumnItemNode.SelType != TypesOfSelect.None)
{
foreach (var reference in GetTypeReferenceDefinitions(context))
{
//SelectedElements.Add(new IDChainDefinition(new ChainPartTypeOrAttributeDefinition(reference.TypeName), aColumnItemNode.SelType, typeName), null);
SelectedElements.Add(new Tuple <AExpressionDefinition, string, SelectValueAssignment>(
new IDChainDefinition(
new ChainPartTypeOrAttributeDefinition(reference.TypeName),
aColumnItemNode.SelType, typeName),
null, aColumnItemNode.ValueAssignment));
}
continue;
}
SelectedElements.Add(new Tuple <AExpressionDefinition, string, SelectValueAssignment>(
aColumnItemNode.ColumnSourceValue, aColumnItemNode.AliasId, aColumnItemNode.ValueAssignment));
}
#endregion
#region whereClauseOpt
if (parseNode.ChildNodes[4].ChildNodes != null && parseNode.ChildNodes[4].ChildNodes.Count > 0)
{
WhereExpressionNode tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode;
if (tempWhereNode.BinaryExpressionDefinition != null)
{
WhereExpressionDefinition = tempWhereNode.BinaryExpressionDefinition;
}
}
#endregion
#region groupClauseOpt
if (HasChildNodes(parseNode.ChildNodes[5]) && HasChildNodes(parseNode.ChildNodes[5].ChildNodes[2]))
{
foreach (ParseTreeNode node in parseNode.ChildNodes[5].ChildNodes[2].ChildNodes)
{
GroupByIDs.Add(((IDNode)node.AstNode).IDChainDefinition);
}
}
#endregion
#region havingClauseOpt
if (HasChildNodes(parseNode.ChildNodes[6]))
{
Having = ((BinaryExpressionNode)parseNode.ChildNodes[6].ChildNodes[1].AstNode).BinaryExpressionDefinition;
}
#endregion
#region orderClauseOpt
if (HasChildNodes(parseNode.ChildNodes[7]))
{
OrderByDefinition = ((OrderByNode)parseNode.ChildNodes[7].AstNode).OrderByDefinition;
}
#endregion
#region Offset
if (HasChildNodes(parseNode.ChildNodes[8]))
{
Offset = ((OffsetNode)parseNode.ChildNodes[8].AstNode).Count;
}
#endregion
#region Limit
if (HasChildNodes(parseNode.ChildNodes[9]))
{
Limit = ((LimitNode)parseNode.ChildNodes[9].AstNode).Count;
}
#endregion
#region Depth
if (HasChildNodes(parseNode.ChildNodes[10]))
{
ResolutionDepth = Convert.ToUInt16(parseNode.ChildNodes[10].ChildNodes[1].Token.Value);
}
#endregion
#region Select Output
if (HasChildNodes(parseNode.ChildNodes[11]))
{
_SelectOutputType = (parseNode.ChildNodes[11].AstNode as SelectOutputOptNode).SelectOutputType;
}
#endregion
}
