public virtual void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
ArgumentUtility.CheckNotNull ("joinClause", joinClause);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
// nothing to do here
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
var subQueryExpression = joinClause.InnerSequence as SubQueryExpression;
if (subQueryExpression != null)
{
VisitQueryModel(subQueryExpression.QueryModel);
if (subQueryExpression.QueryModel.IsIdentityQuery()
&& !subQueryExpression.QueryModel.ResultOperators.Any())
{
joinClause.InnerSequence
= subQueryExpression.QueryModel.MainFromClause.FromExpression;
foreach (var queryAnnotation
in _queryAnnotations
.Where(qa => qa.QuerySource == subQueryExpression.QueryModel.MainFromClause))
{
queryAnnotation.QuerySource = joinClause;
}
}
}
base.VisitJoinClause(joinClause, queryModel, index);
}
public GroupJoinClause (string itemName, Type itemType, JoinClause joinClause)
{
ArgumentUtility.CheckNotNullOrEmpty ("itemName", itemName);
ArgumentUtility.CheckNotNull ("itemType", itemType);
ArgumentUtility.CheckNotNull ("joinClause", joinClause);
ItemName = itemName;
ItemType = itemType;
JoinClause = joinClause;
}
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, string, string> ((o, i) => o.ToString () + i.ToString ());
_node = new JoinExpressionNode (CreateParseInfo (SourceNode, "join"), _innerSequence, _outerKeySelector, _innerKeySelector, _resultSelector);
_joinClause = ExpressionHelper.CreateJoinClause<Cook> ();
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
throw new NotSupportedException ();
/*
// HQL joins work differently, need to simulate using a cross join with a where condition
queryParts.AddFromPart (joinClause);
queryParts.AddWherePart (
"({0} = {1})",
GetHqlExpression (joinClause.OuterKeySelector),
GetHqlExpression (joinClause.InnerKeySelector));
base.VisitJoinClause (joinClause, queryModel, index);
*/
}
public void Intialize()
{
Expression innerSequence = ExpressionHelper.CreateExpression ();
Expression outerKeySelector = ExpressionHelper.CreateExpression ();
Expression innerKeySelector = ExpressionHelper.CreateExpression ();
var joinClause = new JoinClause ("x", typeof(Cook), innerSequence, outerKeySelector, innerKeySelector);
Assert.That (joinClause.ItemName, Is.SameAs ("x"));
Assert.That (joinClause.ItemType, Is.SameAs (typeof (Cook)));
Assert.That (joinClause.InnerSequence, Is.SameAs (innerSequence));
Assert.That (joinClause.InnerKeySelector, Is.SameAs (innerKeySelector));
Assert.That (joinClause.OuterKeySelector, Is.SameAs (outerKeySelector));
}
/// <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 JoinClause Clone(CloneContext cloneContext)
{
ArgumentUtility.CheckNotNull ("cloneContext", cloneContext);
var clone = new JoinClause (ItemName, ItemType, InnerSequence, OuterKeySelector, InnerKeySelector);
cloneContext.QuerySourceMapping.AddMapping (this, new QuerySourceReferenceExpression (clone));
return clone;
}
public void AddJoin(JoinClause join)
{
Joins.Add(join);
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
base.VisitJoinClause(joinClause, queryModel, index);
var subQuery = joinClause.InnerSequence as SubQueryExpression;
if (subQuery != null)
{
var isOuter = subQuery.QueryModel.ResultOperators.OfType<DefaultIfEmptyResultOperator>().Any();
_builder.AppendFormat("{0} join (", isOuter ? "left outer" : "inner");
VisitQueryModel(subQuery.QueryModel, true);
var alias = _aliases.GetTableAlias(subQuery.QueryModel.MainFromClause);
_builder.AppendFormat(") as {0} on (", alias);
}
else
{
var innerExpr = joinClause.InnerSequence as ConstantExpression;
if (innerExpr == null)
throw new NotSupportedException("Unexpected JOIN inner sequence (subqueries are not supported): " +
joinClause.InnerSequence);
if (!(innerExpr.Value is ICacheQueryable))
throw new NotSupportedException("Unexpected JOIN inner sequence " +
"(only results of cache.ToQueryable() are supported): " +
innerExpr.Value);
var queryable = ExpressionWalker.GetCacheQueryable(joinClause);
var tableName = ExpressionWalker.GetTableNameWithSchema(queryable);
var alias = _aliases.GetTableAlias(joinClause);
_builder.AppendFormat("inner join {0} as {1} on (", tableName, alias);
}
BuildJoinCondition(joinClause.InnerKeySelector, joinClause.OuterKeySelector);
_builder.Append(") ");
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
var equalityVisitor = new EqualityHqlGenerator(VisitorParameters);
var whereClause = equalityVisitor.Visit(joinClause.InnerKeySelector, joinClause.OuterKeySelector);
_hqlTree.AddWhereClause(whereClause);
_hqlTree.AddFromClause(
_hqlTree.TreeBuilder.Range(
HqlGeneratorExpressionTreeVisitor.Visit(joinClause.InnerSequence, VisitorParameters),
_hqlTree.TreeBuilder.Alias(joinClause.ItemName)));
}
/// <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 void SetUp ()
{
_joinClause = ExpressionHelper.CreateJoinClause<Cook> ();
_cloneContext = new CloneContext (new QuerySourceMapping());
}
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 JoinClause CreateJoinClause(ClauseGenerationContext clauseGenerationContext)
{
var dummyInnerKeySelector = Expression.Constant (null);
var joinClause = new JoinClause (
ResultSelector.Parameters[1].Name,
ResultSelector.Parameters[1].Type,
InnerSequence,
GetResolvedOuterKeySelector (clauseGenerationContext),
dummyInnerKeySelector);
clauseGenerationContext.AddContextInfo (this, joinClause);
joinClause.InnerKeySelector = GetResolvedInnerKeySelector (clauseGenerationContext);
return joinClause;
}
//TODO: Implement Joins
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel,
GroupJoinClause groupJoinClause)
{
base.VisitJoinClause(joinClause, queryModel, groupJoinClause);
}
/// <summary>
/// Visits a join against either a constant expression of IBucketQueryable, or a subquery based on an IBucketQueryable
/// </summary>
/// <param name="joinClause">Join clause being visited</param>
/// <returns>N1QlFromQueryPart to be added to the QueryPartsAggregator. JoinType is defaulted to INNER JOIN.</returns>
/// <remarks>The InnerKeySelector must be selecting the N1QlFunctions.Key of the InnerSequence</remarks>
private N1QlFromQueryPart ParseJoinClause(JoinClause joinClause)
{
switch (joinClause.InnerSequence.NodeType)
{
case ExpressionType.Constant:
return VisitConstantExpressionJoinClause(joinClause, joinClause.InnerSequence as ConstantExpression);
case SubQueryExpression.ExpressionType:
var subQuery = joinClause.InnerSequence as SubQueryExpression;
if ((subQuery == null) || subQuery.QueryModel.ResultOperators.Any() || subQuery.QueryModel.MainFromClause.FromExpression.NodeType != ExpressionType.Constant)
{
throw new NotSupportedException("Unsupported Join Inner Sequence");
}
// be sure the subquery clauses use the same name
_queryGenerationContext.ExtentNameProvider.LinkExtents(joinClause,
subQuery.QueryModel.MainFromClause);
var fromPart = VisitConstantExpressionJoinClause(joinClause,
subQuery.QueryModel.MainFromClause.FromExpression as ConstantExpression);
VisitBodyClauses(subQuery.QueryModel.BodyClauses, subQuery.QueryModel);
return fromPart;
default:
throw new NotSupportedException("Unsupported Join Inner Sequence");
}
}
/// <summary>
/// Visits a join against a constant expression, which must be an IBucketQueryable implementation
/// </summary>
/// <param name="joinClause">Join clause being visited</param>
/// <param name="constantExpression">Constant expression that is the InnerSequence of the JoinClause</param>
/// <returns>N1QlFromQueryPart to be added to the QueryPartsAggregator. JoinType is defaulted to INNER JOIN.</returns>
/// <remarks>The InnerKeySelector must be selecting the N1QlFunctions.Key of the InnerSequence</remarks>
private N1QlFromQueryPart VisitConstantExpressionJoinClause(JoinClause joinClause, ConstantExpression constantExpression)
{
string bucketName = null;
if (constantExpression != null)
{
var bucketQueryable = constantExpression.Value as IBucketQueryable;
if (bucketQueryable != null)
{
bucketName = bucketQueryable.BucketName;
}
}
if (bucketName == null)
{
throw new NotSupportedException("N1QL Joins Must Be Against IBucketQueryable");
}
var keyExpression = joinClause.InnerKeySelector as MethodCallExpression;
if ((keyExpression == null) ||
(keyExpression.Method != typeof(N1QlFunctions).GetMethod("Key")) ||
(keyExpression.Arguments.Count != 1))
{
throw new NotSupportedException("N1QL Join Selector Must Be A Call To N1QlFunctions.Key");
}
if (!(keyExpression.Arguments[0] is QuerySourceReferenceExpression))
{
throw new NotSupportedException("N1QL Join Selector Call To N1QlFunctions.Key Must Reference The Inner Sequence");
}
return new N1QlFromQueryPart()
{
Source = N1QlHelpers.EscapeIdentifier(bucketName),
ItemName = GetExtentName(joinClause),
OnKeys = GetN1QlExpression(joinClause.OuterKeySelector),
JoinType = "INNER JOIN"
};
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
// basic join clause is an INNER JOIN against another bucket
EnsureNotArraySubquery();
var fromQueryPart = ParseJoinClause(joinClause);
_queryPartsAggregator.AddFromPart(fromQueryPart);
base.VisitJoinClause(joinClause, 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 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")));
}
public void TransformExpressions ()
{
var oldInnerSequence = ExpressionHelper.CreateExpression ();
var oldOuterKeySelector = ExpressionHelper.CreateExpression ();
var oldInnerKeySelector = ExpressionHelper.CreateExpression ();
var newInnerSequence = ExpressionHelper.CreateExpression ();
var newOuterKeySelector = ExpressionHelper.CreateExpression ();
var newInnerKeySelector = ExpressionHelper.CreateExpression ();
var clause = new JoinClause ("x", typeof (Cook), oldInnerSequence, oldOuterKeySelector, oldInnerKeySelector);
clause.TransformExpressions (ex =>
{
if (ex == oldInnerSequence)
return newInnerSequence;
else if (ex == oldOuterKeySelector)
return newOuterKeySelector;
else if (ex == oldInnerKeySelector)
return newInnerKeySelector;
else
{
Assert.Fail();
return null;
}
});
Assert.That (clause.InnerSequence, Is.SameAs (newInnerSequence));
Assert.That (clause.OuterKeySelector, Is.SameAs (newOuterKeySelector));
Assert.That (clause.InnerKeySelector, Is.SameAs (newInnerKeySelector));
}
public SqlTableBase AddJoinClause (JoinClause joinClause)
{
ArgumentUtility.CheckNotNull ("joinClause", joinClause);
var table = AddQuerySource (joinClause, joinClause.InnerSequence);
var whereCondition = Expression.Equal (joinClause.OuterKeySelector, joinClause.InnerKeySelector);
SqlStatementBuilder.AddWhereCondition (_stage.PrepareWhereExpression (whereCondition, _context));
return table;
}
public new void ToString ()
{
var joinClause = new JoinClause ("x", typeof (Cook), Expression.Constant (0), Expression.Constant (1), Expression.Constant (2));
Assert.That (joinClause.ToString (), Is.EqualTo ("join Cook x in 0 on 1 equals 2"));
}
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 VisitJoinClause(JoinClause joinClause, QueryModel queryModel, GroupJoinClause groupJoinClause)
{
throw new NotSupportedException("Join clauses not supported");
}
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 VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
QueryParts.AddJoin(joinClause);
base.VisitJoinClause(joinClause, queryModel, index);
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, GroupJoinClause groupJoinClause)
{
_namer.Add(joinClause);
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
_queryPartsAggregator.AddFromPart(new N1QlFromQueryPart()
{
Source = joinClause.ItemType.Name.ToLower(),
ItemName = joinClause.ItemName
});
_queryPartsAggregator.AddWherePart("ON KEYS ARRAY {0} FOR {1} IN {2} END",
joinClause.OuterKeySelector,
joinClause.InnerKeySelector,
joinClause.ItemName);
base.VisitJoinClause(joinClause, queryModel, index);
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
_namer.Add(joinClause);
}