public virtual void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
{
ArgumentUtility.CheckNotNull ("groupJoinClause", groupJoinClause);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
groupJoinClause.JoinClause.Accept (this, queryModel, groupJoinClause);
}
/// <summary>
/// Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
/// </summary>
/// <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="CloneContext"/>.</param>
/// <returns>A clone of this clause.</returns>
public GroupJoinClause Clone(CloneContext cloneContext)
{
var clone = new GroupJoinClause(ItemName, ItemType, JoinClause.Clone(cloneContext));
cloneContext.QuerySourceMapping.AddMapping(this, new QuerySourceReferenceExpression(clone));
return(clone);
}
public virtual void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, GroupJoinClause groupJoinClause)
{
ArgumentUtility.CheckNotNull ("joinClause", joinClause);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
ArgumentUtility.CheckNotNull ("groupJoinClause", groupJoinClause);
// nothing to do here
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitJoinClause(Remotion.Linq.Clauses.JoinClause,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.GroupJoinClause)"/>
/// method. This overload is used when visiting a <see cref="JoinClause"/> that is held by a <see cref="GroupJoinClause"/>.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="groupJoinClause">The <see cref="GroupJoinClause"/> holding this <see cref="JoinClause"/> instance.</param>
public void Accept(IQueryModelVisitor visitor, QueryModel queryModel, GroupJoinClause groupJoinClause)
{
ArgumentUtility.CheckNotNull("visitor", visitor);
ArgumentUtility.CheckNotNull("queryModel", queryModel);
ArgumentUtility.CheckNotNull("groupJoinClause", groupJoinClause);
visitor.VisitJoinClause(this, queryModel, groupJoinClause);
}
public void Intialize ()
{
var groupJoinClause = new GroupJoinClause ("x", typeof (IEnumerable<Cook>), _joinClause);
Assert.That (groupJoinClause.ItemName, Is.SameAs ("x"));
Assert.That (groupJoinClause.ItemType, Is.SameAs (typeof (IEnumerable<Cook>)));
Assert.That (groupJoinClause.JoinClause, Is.SameAs (_joinClause));
}
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression)
{
if (_results.AggregatingClauses.Contains(expression.ReferencedQuerySource as GroupJoinClause))
{
_groupJoin = expression.ReferencedQuerySource as GroupJoinClause;
}
return base.VisitQuerySourceReferenceExpression(expression);
}
/// <summary>
/// Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
/// </summary>
/// <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="CloneContext"/>.</param>
/// <returns>A clone of this clause.</returns>
public GroupJoinClause Clone(CloneContext cloneContext)
{
ArgumentUtility.CheckNotNull("cloneContext", cloneContext);
var clone = new GroupJoinClause(ItemName, ItemType, JoinClause.Clone(cloneContext));
cloneContext.QuerySourceMapping.AddMapping(this, new QuerySourceReferenceExpression(clone));
return(clone);
}
public override void SetUp ()
{
base.SetUp ();
_innerSequence = ExpressionHelper.CreateExpression ();
_outerKeySelector = ExpressionHelper.CreateLambdaExpression<string, string> (o => o.ToString ());
_innerKeySelector = ExpressionHelper.CreateLambdaExpression<string, string> (i => i.ToString ());
_resultSelector = ExpressionHelper.CreateLambdaExpression<string, IEnumerable<string>, string> ((o, into) => o.ToString() + into.ToString());
_node = new GroupJoinExpressionNode (
CreateParseInfo (SourceNode, "groupJoin"), _innerSequence, _outerKeySelector, _innerKeySelector, _resultSelector);
_groupJoinClause = ExpressionHelper.CreateGroupJoinClause<Cook>();
}
private bool IsFlattenedJoin(GroupJoinClause nonAggregatingJoin)
{
if (_locator.Clauses.Count == 1)
{
var from = _locator.Clauses[0] as AdditionalFromClause;
if (from != null)
{
return true;
}
}
return false;
}
private void ProcessFlattenedJoin(GroupJoinClause nonAggregatingJoin)
{
// Need to:
// 1. Remove the group join and replace it with a join
// 2. Remove the corresponding "from" clause (the thing that was doing the flattening)
// 3. Rewrite the selector to reference the "join" rather than the "from" clause
SwapClause(nonAggregatingJoin, nonAggregatingJoin.JoinClause);
// TODO - don't like use of _locator here; would rather we got this passed in. Ditto on next line (esp. the cast)
_model.BodyClauses.Remove(_locator.Clauses[0]);
var querySourceSwapper = new SwapQuerySourceVisitor((IQuerySource) _locator.Clauses[0], nonAggregatingJoin.JoinClause);
_model.SelectClause.TransformExpressions(querySourceSwapper.Swap);
}
public void SetUp ()
{
_mockRepository = new MockRepository();
_visitorMock = _mockRepository.StrictMock<TestQueryModelVisitor>();
_bodyClauseMock1 = _mockRepository.StrictMock<IBodyClause>();
_bodyClauseMock2 = _mockRepository.StrictMock<IBodyClause>();
_ordering1 = new Ordering (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
_ordering2 = new Ordering (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
_resultOperator1 = new TestResultOperator();
_resultOperator2 = new TestResultOperator();
_queryModel = ExpressionHelper.CreateQueryModel<Cook>();
_orderByClause = ExpressionHelper.CreateOrderByClause();
_groupJoinClause = ExpressionHelper.CreateGroupJoinClause<Cook>();
}
public void SetUp ()
{
_mockRepository = new MockRepository();
_visitorMock = _mockRepository.StrictMock<QueryModelVisitorBase>();
_testVisitor = new TestQueryModelVisitor ();
_bodyClauseMock1 = _mockRepository.StrictMock<WhereClause> (ExpressionHelper.CreateExpression());
_bodyClauseMock2 = _mockRepository.StrictMock<WhereClause> (ExpressionHelper.CreateExpression());
_orderingMock1 = _mockRepository.StrictMock<Ordering> (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
_orderingMock2 = _mockRepository.StrictMock<Ordering> (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
_resultOperatorMock1 = _mockRepository.StrictMock<ResultOperatorBase> ();
_resultOperatorMock2 = _mockRepository.StrictMock<ResultOperatorBase> ();
_queryModel = ExpressionHelper.CreateQueryModel<Cook> ();
_orderByClause = ExpressionHelper.CreateOrderByClause ();
_groupJoinClause = ExpressionHelper.CreateGroupJoinClause<Cook> ();
}
private bool IsHierarchicalJoin(GroupJoinClause nonAggregatingJoin)
{
return _locator.Clauses.Count == 0;
}
private bool IsOuterJoin(GroupJoinClause nonAggregatingJoin)
{
return false;
}
public void VisitQuerySourceReferenceExpression_WithNonNullWhereCondition ()
{
var memberInfo = typeof (Cook).GetProperty ("Assistants");
var sqlTableReferenceExpression = new SqlTableReferenceExpression (SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook)));
var innerSequenceExpression =
Expression.MakeMemberAccess (
sqlTableReferenceExpression, memberInfo);
var joinClause = new JoinClause (
"x",
typeof (Cook[]),
innerSequenceExpression,
Expression.Constant (new Cook()),
Expression.Constant (new Cook()));
var groupJoinClause = new GroupJoinClause ("g", typeof (Cook[]), joinClause);
var querySourceReferenceExpression = new QuerySourceReferenceExpression (groupJoinClause);
var fakeWhereExpression = Expression.Constant (true);
_stageMock
.Expect (mock => mock.PrepareWhereExpression (Arg<Expression>.Matches (e => e is BinaryExpression), Arg.Is (_context)))
.WhenCalled (
mi =>
SqlExpressionTreeComparer.CheckAreEqualTrees (
Expression.Equal (groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector),
(Expression) mi.Arguments[0]))
.Return (fakeWhereExpression);
_stageMock.Replay();
_visitor.VisitQuerySourceReferenceExpression (querySourceReferenceExpression);
_stageMock.VerifyAllExpectations();
Assert.That (_visitor.FromExpressionInfo != null); // inline condition because of ReSharper
var fromExpressionInfo = (FromExpressionInfo) _visitor.FromExpressionInfo;
Assert.That (fromExpressionInfo.WhereCondition, Is.AssignableTo (typeof (BinaryExpression)));
Assert.That (fromExpressionInfo.WhereCondition.NodeType, Is.EqualTo(ExpressionType.AndAlso));
Assert.That (((BinaryExpression) fromExpressionInfo.WhereCondition).Left, Is.TypeOf(typeof(JoinConditionExpression)));
Assert.That (((JoinConditionExpression) ((BinaryExpression) fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo, Is.TypeOf (typeof (UnresolvedCollectionJoinInfo)));
Assert.That (
((UnresolvedCollectionJoinInfo) ((JoinConditionExpression) ((BinaryExpression) fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo).SourceExpression, Is.SameAs(sqlTableReferenceExpression));
Assert.That (
((UnresolvedCollectionJoinInfo) ((JoinConditionExpression) ((BinaryExpression) fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo).MemberInfo, Is.SameAs (memberInfo));
Assert.That (((JoinConditionExpression) ((BinaryExpression) fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinSemantics, Is.EqualTo(JoinSemantics.Inner));
Assert.That (((BinaryExpression) fromExpressionInfo.WhereCondition).Right, Is.SameAs (fakeWhereExpression));
}
public override void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
{
throw new NotSupportedException("Group join clauses not supported");
}
//TODO: Implement Joins
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel,
GroupJoinClause groupJoinClause)
{
base.VisitJoinClause(joinClause, queryModel, groupJoinClause);
}
public override void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
{
QueryParts.AddJoin(groupJoinClause);
base.VisitGroupJoinClause(groupJoinClause, queryModel, index);
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitJoinClause(Remotion.Linq.Clauses.JoinClause,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.GroupJoinClause)"/>
/// method. This overload is used when visiting a <see cref="JoinClause"/> that is held by a <see cref="GroupJoinClause"/>.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="groupJoinClause">The <see cref="GroupJoinClause"/> holding this <see cref="JoinClause"/> instance.</param>
public virtual void Accept(IQueryModelVisitor visitor, QueryModel queryModel, GroupJoinClause groupJoinClause)
{
ArgumentUtility.CheckNotNull ("visitor", visitor);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
ArgumentUtility.CheckNotNull ("groupJoinClause", groupJoinClause);
visitor.VisitJoinClause (this, queryModel, groupJoinClause);
}
public override void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
{
throw new NotImplementedException();
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitJoinClause(Remotion.Linq.Clauses.JoinClause,Remotion.Linq.QueryModel,Remotion.Linq.Clauses.GroupJoinClause)"/>
/// method. This overload is used when visiting a <see cref="JoinClause"/> that is held by a <see cref="GroupJoinClause"/>.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="groupJoinClause">The <see cref="GroupJoinClause"/> holding this <see cref="JoinClause"/> instance.</param>
public virtual void Accept(IQueryModelVisitor visitor, QueryModel queryModel, GroupJoinClause groupJoinClause)
{
visitor.VisitJoinClause(this, queryModel, groupJoinClause);
}
public void SetUp ()
{
_joinClause = ExpressionHelper.CreateJoinClause<Cook> ();
_groupJoinClause = ExpressionHelper.CreateGroupJoinClause<Cook> (_joinClause);
_cloneContext = new CloneContext (new QuerySourceMapping ());
}
public new void ToString ()
{
var joinClause = new JoinClause ("x", typeof (Cook), Expression.Constant (0), Expression.Constant (1), Expression.Constant (2));
var groupJoinClause = new GroupJoinClause ("y", typeof (IEnumerable<Cook>), joinClause);
Assert.That (groupJoinClause.ToString (), Is.EqualTo ("join Cook x in 0 on 1 equals 2 into IEnumerable`1 y"));
}
public override void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
{
_namer.Add(groupJoinClause);
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, GroupJoinClause groupJoinClause)
{
_namer.Add(joinClause);
}
public void VisitQuerySourceReferenceExpression ()
{
var innerSequenceExpression = Expression.Constant (new[] { new Cook() });
var joinClause = new JoinClause (
"x",
typeof (Cook[]),
innerSequenceExpression,
Expression.Constant (new Cook()),
Expression.Constant (new Cook()));
var groupJoinClause = new GroupJoinClause ("g", typeof (Cook[]), joinClause);
var querySourceReferenceExpression = new QuerySourceReferenceExpression (groupJoinClause);
var fakeWhereExpression = Expression.Constant (true);
_stageMock
.Expect (mock => mock.PrepareWhereExpression (Arg<Expression>.Matches (e => e is BinaryExpression), Arg.Is (_context)))
.WhenCalled (
mi =>
SqlExpressionTreeComparer.CheckAreEqualTrees (
Expression.Equal (groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector),
(Expression) mi.Arguments[0]))
.Return (fakeWhereExpression);
_stageMock.Replay();
var result = _visitor.VisitQuerySourceReferenceExpression (querySourceReferenceExpression);
_stageMock.VerifyAllExpectations();
Assert.That (_visitor.FromExpressionInfo, Is.Not.Null);
var fromExpressionInfo = (FromExpressionInfo) _visitor.FromExpressionInfo;
SqlExpressionTreeComparer.CheckAreEqualTrees (
new SqlTableReferenceExpression (fromExpressionInfo.SqlTable),
_context.GetExpressionMapping (new QuerySourceReferenceExpression (groupJoinClause.JoinClause)));
SqlExpressionTreeComparer.CheckAreEqualTrees (fromExpressionInfo.ItemSelector, result);
Assert.That (((UnresolvedTableInfo) ((SqlTable) fromExpressionInfo.SqlTable).TableInfo).ItemType, Is.EqualTo (typeof (Cook)));
Assert.That (fromExpressionInfo.WhereCondition, Is.SameAs (fakeWhereExpression));
Assert.That (fromExpressionInfo.ExtractedOrderings.Count, Is.EqualTo (0));
}
public override void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
{
throw new NotSupportedException("Not implemented yet.");
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, GroupJoinClause groupJoinClause)
=> joinClause.TransformExpressions(TransformingVisitor.Visit);
public override void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
{
base.VisitGroupJoinClause(groupJoinClause, queryModel, index);
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel,
GroupJoinClause groupJoinClause)
{
// Store the group join with the expectation it will be used later by an additional from clause
EnsureNotArraySubquery();
_unclaimedGroupJoins.Add(new UnclaimedGroupJoin()
{
JoinClause = joinClause,
GroupJoinClause = groupJoinClause
});
base.VisitJoinClause(joinClause, queryModel, groupJoinClause);
}
public void AddJoin(GroupJoinClause join)
{
GroupJoins.Add(join);
}
public void VisitQuerySourceReferenceExpression_WithExtractedOrderings ()
{
var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook));
var sqlTableReferenceExpression = new SqlTableReferenceExpression (sqlTable);
var selectProjection = new NamedExpression("test", Expression.MakeMemberAccess (sqlTableReferenceExpression, typeof (Cook).GetProperty ("Name")));
var orderingExpression = Expression.MakeMemberAccess (sqlTableReferenceExpression, typeof (Cook).GetProperty ("ID"));
var sqlStatement = new SqlStatementBuilder
{
DataInfo = new StreamedSequenceInfo(typeof (DateTime[]), Expression.Constant (new DateTime (2000, 1, 1))),
SelectProjection = selectProjection,
SqlTables = { sqlTable },
Orderings =
{ new Ordering (orderingExpression, OrderingDirection.Asc) }
}.GetSqlStatement();
var fakeSelectExpression = Expression.Constant (new KeyValuePair<string, int>("test", 5));
var fakeWhereExpression = Expression.Constant (true);
var innerSequenceExpression = new SqlSubStatementExpression (sqlStatement);
var joinClause = new JoinClause (
"x",
typeof (Cook[]),
innerSequenceExpression,
Expression.Constant (new Cook ()),
Expression.Constant (new Cook ()));
var groupJoinClause = new GroupJoinClause ("g", typeof (Cook[]), joinClause);
var querySourceReferenceExpression = new QuerySourceReferenceExpression (groupJoinClause);
_stageMock
.Expect (mock => mock.PrepareSelectExpression(Arg<Expression>.Is.Anything, Arg<ISqlPreparationContext>.Is.Anything))
.Return (fakeSelectExpression);
_stageMock
.Expect (mock => mock.PrepareWhereExpression (Arg<Expression>.Matches (e => e is BinaryExpression), Arg.Is (_context)))
.WhenCalled (
mi =>
SqlExpressionTreeComparer.CheckAreEqualTrees (
Expression.Equal (groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector),
(Expression) mi.Arguments[0]))
.Return (fakeWhereExpression);
_stageMock.Replay ();
_visitor.VisitQuerySourceReferenceExpression (querySourceReferenceExpression);
_stageMock.VerifyAllExpectations ();
Assert.That (_visitor.FromExpressionInfo != null); // inline condition because of ReSharper
var fromExpressionInfo = (FromExpressionInfo) _visitor.FromExpressionInfo;
Assert.That (fromExpressionInfo.ExtractedOrderings.Count, Is.EqualTo(1));
Assert.That (fromExpressionInfo.ExtractedOrderings[0].Expression, Is.AssignableTo(typeof(MemberExpression)));
Assert.That (((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression, Is.TypeOf(typeof(SqlTableReferenceExpression)));
Assert.That (
((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable, Is.TypeOf (typeof (SqlTable)));
Assert.That (
((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable).TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo)));
var resolvedSubStatementtableInfo =
(ResolvedSubStatementTableInfo) ((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable).TableInfo;
Assert.That (resolvedSubStatementtableInfo.SqlStatement.SelectProjection, Is.SameAs(fakeSelectExpression));
Assert.That (resolvedSubStatementtableInfo.SqlStatement.Orderings.Count, Is.EqualTo (0));
Assert.That (((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Member, Is.EqualTo(typeof(KeyValuePair<,>).MakeGenericType(typeof(string), typeof(int)).GetProperty("Value")));
Assert.That (fromExpressionInfo.ItemSelector, Is.AssignableTo (typeof (MemberExpression)));
Assert.That (((MemberExpression) fromExpressionInfo.ItemSelector).Expression, Is.TypeOf(typeof(SqlTableReferenceExpression)));
Assert.That (((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ItemSelector).Expression).SqlTable, Is.TypeOf (typeof (SqlTable)));
Assert.That (
((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ItemSelector).Expression).SqlTable).TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo)));
Assert.That (((MemberExpression) fromExpressionInfo.ItemSelector).Member, Is.EqualTo (typeof (KeyValuePair<,>).MakeGenericType (typeof (string), typeof (int)).GetProperty ("Key")));
}
protected override QueryModel ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var joinClause = JoinExpressionNode.CreateJoinClause (clauseGenerationContext);
var groupJoinClause = new GroupJoinClause (ResultSelector.Parameters[1].Name, ResultSelector.Parameters[1].Type, joinClause);
clauseGenerationContext.AddContextInfo (this, groupJoinClause);
queryModel.BodyClauses.Add (groupJoinClause);
var selectClause = queryModel.SelectClause;
selectClause.Selector = GetResolvedResultSelector (clauseGenerationContext);
return queryModel;
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, GroupJoinClause groupJoinClause)
{
throw new NotSupportedException("Join clauses not supported");
}
