public virtual Expression GetOuterJoinTest(SelectExpression select)
{
// if the column is used in the join condition (equality test)
// if it is null in the database then the join test won't match (null != null) so the row won't appear
// we can safely use this existing column as our test to determine if the outer join produced a row
// find a column that is used in equality test
HashSet <TableAlias> aliases = DeclaredAliasGatherer.Gather(select.From);
List <ColumnExpression> joinColumns = JoinColumnGatherer.Gather(aliases, select).ToList();
if (joinColumns.Count > 0)
{
// prefer one that is already in the projection list.
foreach (ColumnExpression jc in joinColumns)
{
foreach (ColumnDeclaration col in select.Columns)
{
if (jc.Equals(col.Expression))
{
return(jc);
}
}
}
return(joinColumns[0]);
}
// fall back to introducing a constant
return(Expression.Constant(1, typeof(int?)));
}
protected override Expression VisitSelect(SelectExpression select)
{
bool saveIsOuterMostSelect = isOuterMostSelect;
try {
isOuterMostSelect = false;
select = (SelectExpression)base.VisitSelect(select);
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);
if (hasOrderBy)
{
PrependOrderings(select.OrderBy);
}
if (select.IsReverse)
{
ReverseOrderings();
}
IEnumerable <OrderExpression> orderings = null;
if (canReceiveOrderings)
{
orderings = gatheredOrderings;
}
else if (canHaveOrderBy)
{
orderings = select.OrderBy;
}
bool canPassOnOrderings = !saveIsOuterMostSelect && !hasGroupBy && !select.IsDistinct;
ReadOnlyCollection <ColumnDeclaration> columns = select.Columns;
if (gatheredOrderings != null)
{
if (canPassOnOrderings)
{
HashSet <TableAlias> producedAliases = DeclaredAliasGatherer.Gather(select.From);
// reproject order expressions using this select's alias so the outer select will have properly formed expressions
BindResult project = RebindOrderings(gatheredOrderings, select.Alias, producedAliases, select.Columns);
gatheredOrderings = null;
PrependOrderings(project.Orderings);
columns = project.Columns;
}
else
{
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, false);
}
return(select);
}
finally {
isOuterMostSelect = saveIsOuterMostSelect;
}
}
private void MapAliases(Expression a, Expression b)
{
TableAlias[] prodA = DeclaredAliasGatherer.Gather(a).ToArray();
TableAlias[] prodB = DeclaredAliasGatherer.Gather(b).ToArray();
for (int i = 0, n = prodA.Length; i < n; i++)
{
aliasScope.Add(prodA[i], prodB[i]);
}
}
private Expression MakeSubquery(Expression expression)
{
var newAlias = new TableAlias();
HashSet <TableAlias> aliases = DeclaredAliasGatherer.Gather(expression);
var decls = new List <ColumnDeclaration>();
foreach (TableAlias ta in aliases)
{
foreach (ColumnExpression col in columns[ta])
{
string name = decls.GetAvailableColumnName(col.Name);
var decl = new ColumnDeclaration(name, col, col.QueryType);
decls.Add(decl);
var newCol = new ColumnExpression(col.Type, col.QueryType, newAlias, col.Name);
map.Add(col, newCol);
}
}
return(new SelectExpression(newAlias, decls, expression, null));
}
protected override Expression VisitJoin(JoinExpression join)
{
join = (JoinExpression)base.VisitJoin(join);
if (join.Join == JoinType.CrossJoin && currentWhere != null)
{
// try to figure out which parts of the current where expression can be used for a join condition
HashSet <TableAlias> declaredLeft = DeclaredAliasGatherer.Gather(join.Left);
HashSet <TableAlias> declaredRight = DeclaredAliasGatherer.Gather(join.Right);
var declared = new HashSet <TableAlias>(declaredLeft.Union(declaredRight));
Expression[] exprs = currentWhere.Split(ExpressionType.And, ExpressionType.AndAlso);
List <Expression> good = exprs.Where(e => CanBeJoinCondition(e, declaredLeft, declaredRight, declared)).ToList();
if (good.Count > 0)
{
Expression condition = good.Join(ExpressionType.And);
join = UpdateJoin(join, JoinType.InnerJoin, join.Left, join.Right, condition);
Expression newWhere = exprs.Where(e => !good.Contains(e)).Join(ExpressionType.And);
currentWhere = newWhere;
}
}
return(join);
}
protected override Expression VisitJoin(JoinExpression join)
{
join = (JoinExpression)base.VisitJoin(join);
if (join.Join == JoinType.CrossApply || join.Join == 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))
{
SelectExpression selectWithoutWhere = select.SetWhere(null);
HashSet <TableAlias> referencedAliases = ReferencedAliasGatherer.Gather(selectWithoutWhere);
HashSet <TableAlias> declaredAliases = DeclaredAliasGatherer.Gather(join.Left);
referencedAliases.IntersectWith(declaredAliases);
if (referencedAliases.Count == 0)
{
Expression where = select.Where;
select = selectWithoutWhere;
ProjectedColumns pc = ColumnProjector.ProjectColumns(language, where, select.Columns, select.Alias, DeclaredAliasGatherer.Gather(select.From));
select = select.SetColumns(pc.Columns);
where = pc.Projector;
JoinType jt = (where == null) ? JoinType.CrossJoin : (join.Join == JoinType.CrossApply ? JoinType.InnerJoin : JoinType.LeftOuter);
return(new JoinExpression(jt, join.Left, select, where));
}
}
}
}
return(join);
}