public static HashSet <TableAlias> Gather(Expression source)
{
var gatherer = new ReferencedAliasGatherer();
gatherer.Visit(source);
return(gatherer.aliases);
}
private bool GetEquiJoinKeyExpressions(Expression predicate, TableAlias outerAlias, List <Expression> outerExpressions, List <Expression> innerExpressions)
{
if (predicate.NodeType == ExpressionType.Equal)
{
var b = (BinaryExpression)predicate;
ColumnExpression leftCol = this.GetColumnExpression(b.Left);
ColumnExpression rightCol = this.GetColumnExpression(b.Right);
if (leftCol != null && rightCol != null)
{
if (leftCol.Alias == outerAlias)
{
outerExpressions.Add(b.Left);
innerExpressions.Add(b.Right);
return(true);
}
else if (rightCol.Alias == outerAlias)
{
innerExpressions.Add(b.Left);
outerExpressions.Add(b.Right);
return(true);
}
}
}
bool hadKey = false;
var parts = predicate.Split(ExpressionType.And, ExpressionType.AndAlso);
if (parts.Length > 1)
{
foreach (var part in parts)
{
bool hasOuterAliasReference = ReferencedAliasGatherer.Gather(part).Contains(outerAlias);
if (hasOuterAliasReference)
{
if (!GetEquiJoinKeyExpressions(part, outerAlias, outerExpressions, innerExpressions))
{
return(false);
}
hadKey = true;
}
}
}
return(hadKey);
}
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
{
SelectExpression 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 = TableAliasGatherer.Gather(join.Left);
referencedAliases.IntersectWith(declaredAliases);
if (referencedAliases.Count == 0)
{
Expression where = select.Where;
select = selectWithoutWhere;
var pc = ColumnProjector.ProjectColumns(where, select.Columns, select.Alias, TableAliasGatherer.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);
}
private bool CanBeJoinCondition(Expression expression, HashSet <TableAlias> left, HashSet <TableAlias> right, HashSet <TableAlias> all)
{
// an expression is good if it has at least one reference to an alias from both left & right sets and does
// not have any additional references that are not in both left & right sets
var referenced = ReferencedAliasGatherer.Gather(expression);
bool hasLeftKey = false, hasRightKey = false;
foreach (var item in referenced)
{
foreach (var l in left)
{
if (item == l)
{
hasLeftKey = true;
break;
}
}
foreach (var r in right)
{
if (item == r)
{
hasRightKey = true;
break;
}
}
if (!all.Contains(item))
{
return(false);
}
}
return(hasLeftKey && hasRightKey);
}
public static HashSet<TableAlias> Gather(Expression source)
{
var gatherer = new ReferencedAliasGatherer();
gatherer.Visit(source);
return gatherer.aliases;
}