protected override Expression VisitSelect(DbSelectExpression select)
{
var saveCurrentFrom = this.currentFrom;
this.currentFrom = this.VisitSource(select.From);
try
{
var where = this.Visit(select.Where);
var orderBy = this.VisitOrderBy(select.OrderBy);
var groupBy = this.VisitExpressionList(select.GroupBy);
var skip = this.Visit(select.Skip);
var take = this.Visit(select.Take);
var columns = this.VisitColumnDeclarations(select.Columns);
if (this.currentFrom != select.From || where != select.Where || orderBy != select.OrderBy || groupBy != select.GroupBy || take != select.Take || skip != select.Skip || columns != select.Columns)
{
return(new DbSelectExpression(select.Alias, columns, this.currentFrom, where, orderBy, groupBy, select.IsDistinct, skip, take, select.IsReverse));
}
return(select);
}
finally
{
this.currentFrom = saveCurrentFrom;
}
}
public static DbSelectExpression AddRedundantSelect(this DbSelectExpression sel, QueryLanguage language, TableAlias newAlias)
{
var newColumns =
(
from d in sel.Columns
let qt = (d.Expression is DbColumnExpression) ? (d.Expression as DbColumnExpression).QueryType : language.TypeSystem.GetColumnType(d.Expression.Type)
select new DbColumnDeclaration(d.Name, new DbColumnExpression(d.Expression.Type, qt, newAlias, d.Name), qt)
);
var newFrom = new DbSelectExpression
(
newAlias,
sel.Columns,
sel.From,
sel.Where,
sel.OrderBy,
sel.GroupBy,
sel.IsDistinct,
sel.Skip,
sel.Take,
sel.IsReverse
);
return(new DbSelectExpression
(
sel.Alias,
newColumns,
newFrom,
null, null, null, false, null, null, false
));
}
public static bool IsNameMapProjection(DbSelectExpression select)
{
if (select.From is DbTableExpression)
{
return(false);
}
var fromSelect = select.From as DbSelectExpression;
if (fromSelect == null || select.Columns.Count != fromSelect.Columns.Count)
{
return(false);
}
var fromColumns = fromSelect.Columns;
for (int i = 0, n = select.Columns.Count; i < n; i++)
{
var col = select.Columns[i].Expression as DbColumnExpression;
if (col == null || !(col.Name == fromColumns[i].Name))
{
return(false);
}
}
return(true);
}
protected virtual bool CompareSelect(DbSelectExpression a, DbSelectExpression b)
{
var save = this.aliasScope;
try
{
if (this.Compare(a.From, b.From) == false)
{
return(false);
}
this.aliasScope = new ScopedDictionary <TableAlias, TableAlias>(save);
this.MapAliases(a.From, b.From);
return
(
this.Compare(a.Where, b.Where) &&
this.CompareOrderList(a.OrderBy, b.OrderBy) &&
this.CompareExpressionList(a.GroupBy, b.GroupBy) &&
this.Compare(a.Skip, b.Skip) &&
this.Compare(a.Take, b.Take) &&
a.IsDistinct == b.IsDistinct &&
a.IsReverse == b.IsReverse &&
this.CompareColumnDeclarations(a.Columns, b.Columns)
);
}
finally
{
this.aliasScope = save;
}
}
protected override Expression VisitSelect(DbSelectExpression select)
{
this.Visit(select.Where);
this.VisitOrderBy(select.OrderBy);
this.VisitColumnDeclarations(select.Columns);
return(select);
}
public static DbSelectExpression AddColumn(this DbSelectExpression select, DbColumnDeclaration column)
{
var columns = new List <DbColumnDeclaration>(select.Columns)
{
column
};
return(select.SetColumns(columns));
}
public static DbSelectExpression RemoveRedundantFrom(this DbSelectExpression select)
{
if (select.From is DbSelectExpression fromSelect)
{
return(DbSubqueryRemover.Remove(select, fromSelect));
}
return(select);
}
protected DbScalarExpression UpdateScalar(DbScalarExpression scalar, DbSelectExpression select)
{
if (select != scalar.Select)
{
return(new DbScalarExpression(scalar.Type, select));
}
return(scalar);
}
protected DbSelectExpression UpdateSelect(DbSelectExpression select, Expression from, Expression where, IEnumerable <DbOrderExpression> orderBy, IEnumerable <Expression> groupBy, Expression skip, Expression take, bool isDistinct, bool isReverse, IEnumerable <DbColumnDeclaration> columns)
{
if (from != select.From || where != select.Where || orderBy != select.OrderBy || groupBy != select.GroupBy || take != select.Take || skip != select.Skip || isDistinct != select.IsDistinct || columns != select.Columns || isReverse != select.IsReverse)
{
return(new DbSelectExpression(select.Alias, columns, from, where, orderBy, groupBy, isDistinct, skip, take, isReverse));
}
return(select);
}
protected DbExistsExpression UpdateExists(DbExistsExpression exists, DbSelectExpression select)
{
if (select != exists.Select)
{
return(new DbExistsExpression(select));
}
return(exists);
}
protected override Expression VisitSelect(DbSelectExpression select)
{
var newAlias = new TableAlias();
this.map[select.Alias] = newAlias;
select = base.VisitSelect(select) as DbSelectExpression;
return(new DbSelectExpression(newAlias, select.Columns, select.From, select.Where, select.OrderBy, select.GroupBy, select.IsDistinct, select.Skip, select.Take, select.IsReverse));
}
public static bool HasAggregates(DbSelectExpression expression)
{
var checker = new DbAggregateChecker();
if (checker != null)
{
checker.Visit(expression);
}
return(checker.hasAggregate);
}
protected override Expression VisitSelect(DbSelectExpression select)
{
if (this.selectsToRemove.Contains(select))
{
return(this.Visit(select.From));
}
else
{
return(base.VisitSelect(select));
}
}
protected override Expression VisitSelect(DbSelectExpression select)
{
if (first)
{
first = false;
return(base.VisitSelect(select));
}
return(select);
}
public static DbSelectExpression RemoveColumn(this DbSelectExpression select, DbColumnDeclaration column)
{
var columns = new List <DbColumnDeclaration>(select.Columns);
if (columns != null)
{
columns.Remove(column);
}
return(select.SetColumns(columns));
}
private bool CanJoinOnClient(DbSelectExpression select)
{
return
(
this.canJoinOnClient &&
this.currentMember != null &&
!this.policy.IsDeferLoaded(this.currentMember) &&
!select.IsDistinct &&
(select.GroupBy == null || select.GroupBy.Count == 0) &&
!DbAggregateChecker.HasAggregates(select)
);
}
protected virtual Expression VisitSelect(DbSelectExpression select)
{
var from = this.VisitSource(select.From);
var where = this.Visit(select.Where);
var orderBy = this.VisitOrderBy(select.OrderBy);
var groupBy = this.VisitExpressionList(select.GroupBy);
var skip = this.Visit(select.Skip);
var take = this.Visit(select.Take);
var columns = this.VisitColumnDeclarations(select.Columns);
return(this.UpdateSelect(select, from, where, orderBy, groupBy, skip, take, select.IsDistinct, select.IsReverse, columns));
}
protected override Expression VisitSelect(DbSelectExpression select)
{
select = base.VisitSelect(select) as DbSelectExpression;
var redundant = RedundantSubqueryGatherer.Gather(select.From);
if (redundant != null)
{
select = DbSubqueryRemover.Remove(select, redundant);
}
return(select);
}
protected override Expression VisitProjection(DbProjectionExpression proj)
{
if (isTopLevel)
{
isTopLevel = false;
this.currentSelect = proj.Select;
var projector = this.Visit(proj.Projector);
if (projector != proj.Projector || this.currentSelect != proj.Select)
{
return(new DbProjectionExpression(this.currentSelect, projector, proj.Aggregator));
}
return(proj);
}
if (proj.IsSingleton && this.CanJoinOnServer(this.currentSelect))
{
var newAlias = new TableAlias();
this.currentSelect = this.currentSelect.AddRedundantSelect(this.language, newAlias);
var source = DbColumnMapper.Map(proj.Select, newAlias, this.currentSelect.Alias) as DbSelectExpression;
var pex = this.language.AddOuterJoinTest(new DbProjectionExpression(source, proj.Projector));
var pc = DbColumnProjector.ProjectColumns(this.language, pex.Projector, this.currentSelect.Columns, this.currentSelect.Alias, newAlias, proj.Select.Alias);
var join = new DbJoinExpression(JoinType.OuterApply, this.currentSelect.From, pex.Select, null);
this.currentSelect = new DbSelectExpression(this.currentSelect.Alias, pc.Columns, join, null);
return(this.Visit(pc.Projector));
}
var saveTop = this.isTopLevel;
var saveSelect = this.currentSelect;
this.isTopLevel = true;
this.currentSelect = null;
var result = base.VisitProjection(proj);
this.isTopLevel = saveTop;
this.currentSelect = saveSelect;
return(result);
}
protected override Expression VisitSelect(DbSelectExpression select)
{
select = base.VisitSelect(select) as DbSelectExpression;
var cols = select.Columns.OrderBy(c => c.Name).ToList();
var removed = new BitArray(select.Columns.Count);
var anyRemoved = false;
for (int i = 0, n = cols.Count; i < n - 1; i++)
{
var ci = cols[i];
var cix = ci.Expression as DbColumnExpression;
var qt = cix != null ? cix.QueryType : ci.QueryType;
var cxi = new DbColumnExpression(ci.Expression.Type, qt, select.Alias, ci.Name);
for (int j = i + 1; j < n; j++)
{
if (!removed.Get(j))
{
var cj = cols[j];
if (SameExpression(ci.Expression, cj.Expression))
{
var cxj = new DbColumnExpression(cj.Expression.Type, qt, select.Alias, cj.Name);
this.map.Add(cxj, cxi);
removed.Set(j, true);
anyRemoved = true;
}
}
}
}
if (anyRemoved)
{
var newDecls = new List <DbColumnDeclaration>();
for (int i = 0, n = cols.Count; i < n; i++)
{
if (!removed.Get(i))
{
newDecls.Add(cols[i]);
}
}
select = select.SetColumns(newDecls);
}
return(select);
}
private static bool IsColumnProjection(DbSelectExpression select)
{
for (int i = 0, n = select.Columns.Count; i < n; i++)
{
var cd = select.Columns[i];
if (cd.Expression.NodeType != (ExpressionType)DbExpressionType.Column && cd.Expression.NodeType != ExpressionType.Constant)
{
return(false);
}
}
return(true);
}
protected override Expression VisitSelect(DbSelectExpression select)
{
if (IsRedudantSubquery(select))
{
if (this.redundant == null)
{
this.redundant = new List <DbSelectExpression>();
}
this.redundant.Add(select);
}
return(select);
}
private static bool IsRedudantSubquery(DbSelectExpression select)
{
return
(
(IsSimpleProjection(select) || IsNameMapProjection(select)) &&
!select.IsDistinct &&
!select.IsReverse &&
select.Take == null &&
select.Skip == null &&
select.Where == null &&
(select.OrderBy == null || select.OrderBy.Count == 0) &&
(select.GroupBy == null || select.GroupBy.Count == 0)
);
}
public static bool IsSimpleProjection(DbSelectExpression select)
{
foreach (var decl in select.Columns)
{
var col = decl.Expression as DbColumnExpression;
if (col == null || decl.Name != col.Name)
{
return(false);
}
}
return(true);
}
protected override Expression VisitClientJoin(DbClientJoinExpression join)
{
var saveTop = this.isTopLevel;
var saveSelect = this.currentSelect;
this.isTopLevel = true;
this.currentSelect = null;
var result = base.VisitClientJoin(join);
this.isTopLevel = saveTop;
this.currentSelect = saveSelect;
return(result);
}
public static DbSelectExpression AddOrderExpression(this DbSelectExpression select, DbOrderExpression ordering)
{
var orderby = new List <DbOrderExpression>();
if (select.OrderBy != null)
{
orderby.AddRange(select.OrderBy);
}
if (orderby != null)
{
orderby.Add(ordering);
}
return(select.SetOrderBy(orderby));
}
public static DbSelectExpression RemoveOrderExpression(this DbSelectExpression select, DbOrderExpression ordering)
{
if (select.OrderBy != null && select.OrderBy.Count > 0)
{
var orderby = new List <DbOrderExpression>(select.OrderBy);
if (orderby != null)
{
orderby.Remove(ordering);
}
return(select.SetOrderBy(orderby));
}
return(select);
}
public static DbSelectExpression SetGroupBy(this DbSelectExpression select, IEnumerable <Expression> groupBy)
{
return(new DbSelectExpression
(
select.Alias,
select.Columns,
select.From,
select.Where,
select.OrderBy,
groupBy,
select.IsDistinct,
select.Skip,
select.Take,
select.IsReverse
));
}
public static DbSelectExpression AddGroupExpression(this DbSelectExpression select, Expression expression)
{
var groupby = new List <Expression>();
if (select.GroupBy != null)
{
groupby.AddRange(select.GroupBy);
}
if (groupby != null)
{
groupby.Add(expression);
}
return(select.SetGroupBy(groupby));
}
public static DbSelectExpression RemoveGroupExpression(this DbSelectExpression select, Expression expression)
{
if (select.GroupBy != null && select.GroupBy.Count > 0)
{
var groupby = new List <Expression>(select.GroupBy);
if (groupby != null)
{
groupby.Remove(expression);
}
return(select.SetGroupBy(groupby));
}
return(select);
}
