protected virtual string GetClauseSql (JoinClause clause)
{
throw new NotImplementedException ();
}
private static bool ObjectReferenceIsInJoinClause(JoinClause clause, ObjectReference reference)
{
return reference.GetOwner().GetAliasOrName().Equals(clause.Table.GetAliasOrName());
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
//// HQL joins work differently, need to simulate using a cross join with a where condition
//var visitor = new HqlGeneratorExpressionTreeVisitor(_parameterAggregator);
//visitor.Visit(joinClause.FromExpression);
//_fromClause = _hqlTreeBuilder.From(
// _hqlTreeBuilder.Range(
// visitor.GetHqlTreeNodes().Single(),
// _hqlTreeBuilder.Alias(fromClause.ItemName)));
//base.VisitMainFromClause(fromClause, queryModel);
//_queryParts.AddFromPart(joinClause);
//_queryParts.AddWherePart(
// "({0} = {1})",
// GetHqlExpression(joinClause.OuterKeySelector),
// GetHqlExpression(joinClause.InnerKeySelector));
//base.VisitJoinClause(joinClause, queryModel, index);
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
throw new NotSupportedException("LinqToExcel does not provide support for the Join() method");
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
var previousQuerySource
= index == 0
? queryModel.MainFromClause
: queryModel.BodyClauses[index - 1] as IQuerySource;
var previousSelectExpression
= previousQuerySource != null
? TryGetQuery(previousQuerySource)
: null;
var previousSelectProjectionCount
= previousSelectExpression?.Projection.Count ?? -1;
base.VisitJoinClause(joinClause, queryModel, index);
if (previousSelectExpression != null)
{
var selectExpression = TryGetQuery(joinClause);
if (selectExpression != null)
{
var filteringExpressionTreeVisitor
= new FilteringExpressionTreeVisitor(this);
var predicate
= filteringExpressionTreeVisitor
.VisitExpression(
Expression.Equal(
joinClause.OuterKeySelector,
joinClause.InnerKeySelector));
if (predicate != null)
{
_queriesBySource.Remove(joinClause);
previousSelectExpression.RemoveRangeFromProjection(previousSelectProjectionCount);
var innerJoinExpression
= previousSelectExpression
.AddInnerJoin(
selectExpression.Tables.Single(),
QuerySourceRequiresMaterialization(joinClause)
? selectExpression.Projection
: Enumerable.Empty <ColumnExpression>());
innerJoinExpression.Predicate = predicate;
Expression
= new QueryFlatteningExpressionTreeVisitor(
previousQuerySource,
joinClause,
QueryCompilationContext,
previousSelectProjectionCount,
LinqOperatorProvider.Join)
.VisitExpression(Expression);
}
else
{
previousSelectExpression.RemoveRangeFromProjection(previousSelectProjectionCount);
}
}
}
}
private Expression CreateJoinsForNavigations(
QuerySourceReferenceExpression outerQuerySourceReferenceExpression,
IEnumerable <INavigation> navigations)
{
var querySourceReferenceExpression = outerQuerySourceReferenceExpression;
var navigationJoins = _navigationJoins;
foreach (var navigation in navigations)
{
var navigationJoin
= navigationJoins
.FirstOrDefault(nj =>
nj.QuerySource == querySourceReferenceExpression.ReferencedQuerySource &&
nj.Navigation == navigation);
if (navigationJoin == null)
{
var targetEntityType = navigation.GetTargetType();
var joinClause
= new JoinClause(
$"{querySourceReferenceExpression.ReferencedQuerySource.ItemName}.{navigation.Name}",
targetEntityType.ClrType,
Expression.Constant(
_createEntityQueryableMethod
.MakeGenericMethod(targetEntityType.ClrType)
.Invoke(null, new object[]
{
_entityQueryProvider
})),
CreatePropertyCallExpression(
querySourceReferenceExpression,
navigation.ForeignKey.Properties.Single()),
Expression.Constant(null));
var innerQuerySourceReferenceExpression
= new QuerySourceReferenceExpression(joinClause);
Expression innerKeySelector
= CreatePropertyCallExpression(
innerQuerySourceReferenceExpression,
targetEntityType.GetPrimaryKey().Properties.Single());
if (innerKeySelector.Type != joinClause.OuterKeySelector.Type)
{
innerKeySelector
= Expression.Convert(
innerKeySelector,
joinClause.OuterKeySelector.Type);
}
joinClause.InnerKeySelector = innerKeySelector;
navigationJoins.Add(
navigationJoin
= new NavigationJoin(
querySourceReferenceExpression.ReferencedQuerySource,
navigation,
joinClause,
innerQuerySourceReferenceExpression));
}
querySourceReferenceExpression = navigationJoin.QuerySourceReferenceExpression;
navigationJoins = navigationJoin.NavigationJoins;
}
return(querySourceReferenceExpression);
}
private Expression CreateJoinsForNavigations(
QuerySourceReferenceExpression outerQuerySourceReferenceExpression,
IEnumerable <INavigation> navigations)
{
var querySourceReferenceExpression = outerQuerySourceReferenceExpression;
var navigationJoins = _navigationJoins;
foreach (var navigation in navigations)
{
var targetEntityType = navigation.GetTargetType();
if (navigation.IsCollection())
{
_queryModel.MainFromClause.FromExpression = CreateEntityQueryable(targetEntityType);
var innerQuerySourceReferenceExpression
= new QuerySourceReferenceExpression(_queryModel.MainFromClause);
_queryModel.BodyClauses.Add(
new WhereClause(
Expression.Equal(
CreateKeyAccessExpression(
querySourceReferenceExpression,
navigation.ForeignKey.Properties),
CreateKeyAccessExpression(
innerQuerySourceReferenceExpression,
navigation.ForeignKey.PrincipalKey.Properties))));
return(_queryModel.MainFromClause.FromExpression);
}
var navigationJoin
= navigationJoins
.FirstOrDefault(nj =>
nj.QuerySource == querySourceReferenceExpression.ReferencedQuerySource &&
nj.Navigation == navigation);
if (navigationJoin == null)
{
var joinClause
= new JoinClause(
$"{querySourceReferenceExpression.ReferencedQuerySource.ItemName}.{navigation.Name}",
targetEntityType.ClrType,
CreateEntityQueryable(targetEntityType),
CreateKeyAccessExpression(
querySourceReferenceExpression,
navigation.ForeignKey.Properties),
Expression.Constant(null));
var innerQuerySourceReferenceExpression
= new QuerySourceReferenceExpression(joinClause);
var innerKeySelector
= CreateKeyAccessExpression(
innerQuerySourceReferenceExpression,
navigation.ForeignKey.PrincipalKey.Properties);
if (innerKeySelector.Type != joinClause.OuterKeySelector.Type)
{
innerKeySelector
= Expression.Convert(
innerKeySelector,
joinClause.OuterKeySelector.Type);
}
joinClause.InnerKeySelector = innerKeySelector;
navigationJoins.Add(
navigationJoin
= new NavigationJoin(
querySourceReferenceExpression.ReferencedQuerySource,
navigation,
joinClause,
innerQuerySourceReferenceExpression));
}
querySourceReferenceExpression = navigationJoin.QuerySourceReferenceExpression;
navigationJoins = navigationJoin.NavigationJoins;
}
return(querySourceReferenceExpression);
}
/// <inheritdoc />
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
throw new InvalidOperationException($"EntitySchemaQuery LINQ provider does not support join operator. Use ESQ column path expressions instead.");
}
public void AddJoin(JoinClause join)
{
Joins.Add(join);
}
/// <summary>
/// 测试初始化
/// </summary>
public JoinClauseTest()
{
_clause = new JoinClause(new SqlServerBuilder(), new SqlServerDialect(), new EntityResolver(), new EntityAliasRegister());
}
/// <summary>
/// 添加到左外连接子句
/// </summary>
/// <param name="sql">Sql语句</param>
/// <returns></returns>
public virtual ISqlBuilder AppendLeftJoin(string sql)
{
JoinClause.AppendLeftJoin(sql);
return(this);
}
/// <summary>
/// 左外连接
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="alias">别名</param>
/// <param name="schema">架构名</param>
/// <returns></returns>
public virtual ISqlBuilder LeftJoin <TEntity>(string alias = null, string schema = null) where TEntity : class
{
JoinClause.LeftJoin <TEntity>(alias, schema);
return(this);
}
/// <summary>
/// 左外连接
/// </summary>
/// <param name="table">表名</param>
/// <param name="alias">别名</param>
/// <returns></returns>
public virtual ISqlBuilder LeftJoin(string table, string alias = null)
{
JoinClause.LeftJoin(table, alias);
return(this);
}
/// <summary>
/// 添加到内连接子句
/// </summary>
/// <param name="action">子查询操作</param>
/// <param name="alias">表别名</param>
/// <returns></returns>
public virtual ISqlBuilder AppendJoin(Action <ISqlBuilder> action, string alias)
{
JoinClause.AppendJoin(action, alias);
return(this);
}
/// <summary>
/// 添加到内连接子句
/// </summary>
/// <param name="builder">Sql生成器</param>
/// <param name="alias">表别名</param>
/// <returns></returns>
public virtual ISqlBuilder AppendJoin(ISqlBuilder builder, string alias)
{
JoinClause.AppendJoin(builder, alias);
return(this);
}
