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); }