public static ProjectedColumns ProjectColumns(Func <Expression, bool> fnCanBeColumn, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases)
{
ColumnProjector projector = new ColumnProjector(fnCanBeColumn, expression, existingColumns, newAlias, existingAliases);
Expression expr = projector.Visit(expression);
return(new ProjectedColumns(expr, projector.columns.AsReadOnly()));
}
protected override Expression VisitProjection(ProjectionExpression proj)
{
SelectExpression save = this.currentSelect;
this.currentSelect = proj.Source;
try
{
if (!this.isTopLevel)
{
if (this.CanJoinOnClient(this.currentSelect))
{
// make a query that combines all the constraints from the outer queries into a single select
SelectExpression newOuterSelect = (SelectExpression)QueryDuplicator.Duplicate(save);
// remap any references to the outer select to the new alias;
SelectExpression newInnerSelect = (SelectExpression)ColumnMapper.Map(proj.Source, newOuterSelect.Alias, save.Alias);
// add outer-join test
ProjectionExpression newInnerProjection = new ProjectionExpression(newInnerSelect, proj.Projector).AddOuterJoinTest();
newInnerSelect = newInnerProjection.Source;
Expression newProjector = newInnerProjection.Projector;
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.language.CanBeColumn, newProjector, newOuterSelect.Columns, newAlias, newOuterSelect.Alias, newInnerSelect.Alias);
JoinExpression join = new JoinExpression(JoinType.OuterApply, newOuterSelect, newInnerSelect, null);
SelectExpression joinedSelect = new SelectExpression(newAlias, pc.Columns, join, null, null, null, proj.IsSingleton, null, null);
// apply client-join treatment recursively
this.currentSelect = joinedSelect;
newProjector = this.Visit(pc.Projector);
// compute keys (this only works if join condition was a single column comparison)
List <Expression> outerKeys = new List <Expression>();
List <Expression> innerKeys = new List <Expression>();
if (this.GetEquiJoinKeyExpressions(newInnerSelect.Where, newOuterSelect.Alias, outerKeys, innerKeys))
{
// outerKey needs to refer to the outer-scope's alias
var outerKey = outerKeys.Select(k => ColumnMapper.Map(k, save.Alias, newOuterSelect.Alias));
// innerKey needs to refer to the new alias for the select with the new join
var innerKey = innerKeys.Select(k => ColumnMapper.Map(k, joinedSelect.Alias, ((ColumnExpression)k).Alias));
ProjectionExpression newProjection = new ProjectionExpression(joinedSelect, newProjector, proj.Aggregator);
return(new ClientJoinExpression(newProjection, outerKey, innerKey));
}
}
}
else
{
this.isTopLevel = false;
}
return(base.VisitProjection(proj));
}
finally
{
this.currentSelect = save;
}
}
protected override Expression VisitProjection(ProjectionExpression proj)
{
if (isTopLevel)
{
isTopLevel = false;
currentSelect = proj.Source;
Expression projector = Visit(proj.Projector);
if (projector != proj.Projector || currentSelect != proj.Source)
{
return(new ProjectionExpression(currentSelect, projector, proj.Aggregator));
}
return(proj);
}
if (proj.IsSingleton && CanJoinOnServer(currentSelect))
{
TableAlias newAlias = new TableAlias();
currentSelect = currentSelect.AddRedundantSelect(newAlias);
// remap any references to the outer select to the new alias;
SelectExpression source =
(SelectExpression)ColumnMapper.Map(proj.Source, newAlias, currentSelect.Alias);
// add outer-join test
ProjectionExpression pex = new ProjectionExpression(source, proj.Projector).AddOuterJoinTest();
var pc = ColumnProjector.ProjectColumns(language.CanBeColumn, pex.Projector, currentSelect.Columns,
currentSelect.Alias, newAlias, proj.Source.Alias);
JoinExpression join = new JoinExpression(JoinType.OuterApply, currentSelect.From, pex.Source, null);
currentSelect = new SelectExpression(currentSelect.Alias, pc.Columns, join, null);
return(Visit(pc.Projector));
}
var saveTop = isTopLevel;
var saveSelect = currentSelect;
isTopLevel = true;
currentSelect = null;
Expression result = base.VisitProjection(proj);
isTopLevel = saveTop;
currentSelect = saveSelect;
return(result);
}
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 = DeclaredAliasGatherer.Gather(join.Left);
referencedAliases.IntersectWith(declaredAliases);
if (referencedAliases.Count == 0)
{
Expression 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;
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 ProjectedColumns ProjectColumns(Expression expression, TableAlias newAlias,
params TableAlias[] existingAliases)
{
return(ColumnProjector.ProjectColumns(mapping.Language.CanBeColumn, expression, null, newAlias,
existingAliases));
}
