private bool CanJoinOnServer(SelectExpression select)
{
// can add singleton (1:0,1) join if no grouping/aggregates or distinct
// **fix** !IsDistinct
return((select.GroupBy == null || select.GroupBy.Count == 0) &&
!AggregateChecker.HasAggregates(select));
}
private bool CanJoinOnClient(SelectExpression select)
{
// can add singleton (1:0,1) join if no grouping/aggregates or distinct
return
(this.canJoinOnClient &&
this.currentMember != null &&
!select.IsDistinct &&
(select.GroupBy == null || select.GroupBy.Count == 0) &&
!AggregateChecker.HasAggregates(select));
}
/// <summary>
/// 访问 <see cref="JoinExpression"/>。
/// </summary>
/// <param name="join">要访问的表达式。</param>
/// <returns></returns>
protected override Expression VisitJoin(JoinExpression join)
{
join = (JoinExpression)base.VisitJoin(join);
if (join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply)
{
if (join.Right is TableExpression)
{
return(new JoinExpression(JoinType.CrossJoin, join.Left, join.Right, null));
}
else
{
var select = join.Right as SelectExpression;
// Only consider rewriting cross apply if
// 1) right side is a select
// 2) other than in the where clause in the right-side select, no left-side declared aliases are referenced
// 3) and has no behavior that would change semantics if the where clause is removed (like groups, aggregates, take, skip, etc).
// Note: it is best to attempt this after redundant subqueries have been removed.
if (select != null &&
select.Take == null &&
select.Skip == null &&
!AggregateChecker.HasAggregates(select) &&
(select.GroupBy == null || select.GroupBy.Count == 0))
{
var selectWithoutWhere = select.SetWhere(null);
var referencedAliases = ReferencedAliasGatherer.Gather(selectWithoutWhere);
var declaredAliases = DeclaredAliasGatherer.Gather(join.Left);
referencedAliases.IntersectWith(declaredAliases);
if (referencedAliases.Count == 0)
{
var where = select.Where;
select = selectWithoutWhere;
var pc = ColumnProjector.ProjectColumns(this.CanBeColumn, where, select.Columns, select.Alias, DeclaredAliasGatherer.Gather(select.From));
select = select.SetColumns(pc.Columns);
where = pc.Projector;
var jt = (where == null) ? JoinType.CrossJoin : (join.JoinType == JoinType.CrossApply ? JoinType.InnerJoin : JoinType.LeftOuter);
return(new JoinExpression(jt, join.Left, select, where));
}
}
}
}
return(join);
}
private static bool CanMergeWithFrom(SelectExpression select, bool isTopLevel)
{
var fromSelect = GetLeftMostSelect(select.From);
if (fromSelect == null)
{
return(false);
}
if (!IsColumnProjection(fromSelect))
{
return(false);
}
var selHasNameMapProjection = IsNameMapProjection(select);
var selHasOrderBy = select.OrderBy != null && select.OrderBy.Count > 0;
var selHasGroupBy = select.GroupBy != null && select.GroupBy.Count > 0;
var selHasAggregates = AggregateChecker.HasAggregates(select);
var selHasJoin = select.From is JoinExpression;
var frmHasOrderBy = fromSelect.OrderBy != null && fromSelect.OrderBy.Count > 0;
var frmHasGroupBy = fromSelect.GroupBy != null && fromSelect.GroupBy.Count > 0;
var frmHasAggregates = AggregateChecker.HasAggregates(fromSelect);
// both cannot have orderby
if (selHasOrderBy && frmHasOrderBy)
{
return(false);
}
// both cannot have groupby
if (selHasGroupBy && frmHasGroupBy)
{
return(false);
}
// these are distinct operations
if (select.IsReverse || fromSelect.IsReverse)
{
return(false);
}
// cannot move forward order-by if outer has group-by
if (frmHasOrderBy && (selHasGroupBy || selHasAggregates || select.IsDistinct))
{
return(false);
}
// cannot move forward group-by if outer has where clause
if (frmHasGroupBy /*&& (select.Where != null)*/) // need to assert projection is the same in order to move group-by forward
{
return(false);
}
// cannot move forward a take if outer has take or skip or distinct
if (fromSelect.Take != null && (select.Take != null || select.Skip != null || select.IsDistinct || selHasAggregates || selHasGroupBy || selHasJoin))
{
return(false);
}
// cannot move forward a skip if outer has skip or distinct
if (fromSelect.Skip != null && (select.Skip != null || select.IsDistinct || selHasAggregates || selHasGroupBy || selHasJoin))
{
return(false);
}
// cannot move forward a distinct if outer has take, skip, groupby or a different projection
if (fromSelect.IsDistinct && (select.Take != null || select.Skip != null || !selHasNameMapProjection || selHasGroupBy || selHasAggregates || (selHasOrderBy && !isTopLevel) || selHasJoin))
{
return(false);
}
if (frmHasAggregates && (select.Take != null || select.Skip != null || select.IsDistinct || selHasAggregates || selHasGroupBy || selHasJoin))
{
return(false);
}
return(true);
}
protected override Expression VisitSelect(SelectExpression select)
{
bool saveIsOuterMostSelect = this.isOuterMostSelect;
try
{
this.isOuterMostSelect = false;
var saveSuppressOrderBy = this.suppressOrderby;
this.suppressOrderby = false;
var saveGatheredOrderings = this.gatheredOrderings;
if (saveSuppressOrderBy)
{
this.gatheredOrderings = null;
this.isOuterMostSelect = true;
}
select = (SelectExpression)base.VisitSelect(select);
this.suppressOrderby = saveSuppressOrderBy;
if (saveSuppressOrderBy)
{
this.gatheredOrderings = saveGatheredOrderings;
}
bool hasOrderBy = select.OrderBy != null && select.OrderBy.Count > 0;
bool hasGroupBy = select.GroupBy != null && select.GroupBy.Count > 0;
bool canHaveOrderBy = saveIsOuterMostSelect || select.Take != null || select.Skip != null;
bool canReceiveOrderings = canHaveOrderBy && !hasGroupBy && !select.IsDistinct && !AggregateChecker.HasAggregates(select) && !suppressOrderby;
if (hasOrderBy)
{
this.PrependOrderings(select.OrderBy);
}
if (select.IsReverse)
{
this.ReverseOrderings();
}
IEnumerable <OrderExpression> orderings = null;
if (canReceiveOrderings)
{
orderings = this.gatheredOrderings;
}
else if (canHaveOrderBy)
{
orderings = select.OrderBy;
}
bool canPassOnOrderings = !saveIsOuterMostSelect && !hasGroupBy && !select.IsDistinct && !suppressOrderby;
ReadOnlyCollection <ColumnDeclaration> columns = select.Columns;
if (this.gatheredOrderings != null)
{
if (canPassOnOrderings)
{
var producedAliases = DeclaredAliasGatherer.Gather(select.From);
// reproject order expressions using this select's alias so the outer select will have properly formed expressions
BindResult project = this.RebindOrderings(this.gatheredOrderings, select.Alias, producedAliases, select.Columns);
this.gatheredOrderings = null;
this.PrependOrderings(project.Orderings);
columns = project.Columns;
}
else
{
this.gatheredOrderings = null;
}
}
if (orderings != select.OrderBy || columns != select.Columns || select.IsReverse)
{
select = new SelectExpression(select.Alias, columns, select.From, select.Where, orderings, select.GroupBy, select.IsDistinct, select.Skip, select.Take, select.Segment, select.Having, false);
}
return(select);
}
finally
{
this.isOuterMostSelect = saveIsOuterMostSelect;
}
}