protected override Expression VisitMemberAccess(MemberExpression m) { Expression source = this.Visit(m.Expression); DbEntityExpression ex = source as DbEntityExpression; if (ex != null && this.mapping.IsAssociation(ex.Entity, m.Member)) { DbProjectionExpression projection = (DbProjectionExpression)this.Visit(this.mapping.CreateMemberExpression(source, ex.Entity, m.Member)); if (this.currentFrom != null && this.mapping.IsSingletonAssociation(ex.Entity, m.Member)) { // convert singleton associations directly to OUTER APPLY projection = projection.AddOuterJoinTest(); Expression newFrom = new DbJoinExpression(DbJoinType.OuterApply, this.currentFrom, projection.Select, null); this.currentFrom = newFrom; return projection.Projector; } return projection; } else { Expression result = QueryBinder.BindMember(source, m.Member); MemberExpression mex = result as MemberExpression; if (mex != null && mex.Member == m.Member && mex.Expression == m.Expression) { return m; } return result; } }
protected virtual bool CompareJoin(DbJoinExpression a, DbJoinExpression b) { if (a.Join != b.Join || !Compare(a.Left, b.Left)) { return(false); } if (a.Join == DbJoinType.CrossApply || a.Join == DbJoinType.OuterApply) { ScopedDictionary <DbTableAlias, DbTableAlias> save = _aliasScope; try { _aliasScope = new ScopedDictionary <DbTableAlias, DbTableAlias>(_aliasScope); MapAliases(a.Left, b.Left); return(Compare(a.Right, b.Right) && Compare(a.Condition, b.Condition)); } finally { _aliasScope = save; } } else { return(Compare(a.Right, b.Right) && Compare(a.Condition, b.Condition)); } }
private Expression FindSimilarRight(DbJoinExpression join, DbJoinExpression compareTo) { if (join == null) { return(null); } if (join.Join == compareTo.Join) { if (join.Right.NodeType == compareTo.Right.NodeType && DbExpressionComparer.AreEqual(join.Right, compareTo.Right)) { if (join.Condition == compareTo.Condition) { return(join.Right); } var scope = new ScopedDictionary <DbTableAlias, DbTableAlias>(null); scope.Add(((DbAliasedExpression)join.Right).Alias, ((DbAliasedExpression)compareTo.Right).Alias); if (DbExpressionComparer.AreEqual(null, scope, join.Condition, compareTo.Condition)) { return(join.Right); } } } Expression result = FindSimilarRight(join.Left as DbJoinExpression, compareTo); if (result == null) { result = FindSimilarRight(join.Right as DbJoinExpression, compareTo); } return(result); }
protected override Expression VisitJoin(DbJoinExpression join) { if (join.Join == DbJoinType.SingletonLeftOuter) { // first visit right side w/o looking at condition Expression right = this.Visit(join.Right); DbAliasedExpression ax = right as DbAliasedExpression; if (ax != null && !this.allColumnsUsed.ContainsKey(ax.Alias)) { // if nothing references the alias on the right, then the join is redundant return(this.Visit(join.Left)); } // otherwise do it the right way Expression cond = this.Visit(join.Condition); Expression left = this.Visit(join.Left); right = this.Visit(join.Right); return(this.UpdateJoin(join, join.Join, left, right, cond)); } else { // visit join in reverse order Expression condition = this.Visit(join.Condition); Expression right = this.VisitSource(join.Right); Expression left = this.VisitSource(join.Left); return(this.UpdateJoin(join, join.Join, left, right, condition)); } }
protected override Expression VisitMemberAccess(MemberExpression m) { Expression source = this.Visit(m.Expression); DbEntityExpression ex = source as DbEntityExpression; if (ex != null && this.mapping.IsAssociation(ex.Entity, m.Member)) { DbProjectionExpression projection = (DbProjectionExpression)this.Visit(this.mapping.CreateMemberExpression(source, ex.Entity, m.Member)); if (this.currentFrom != null && this.mapping.IsSingletonAssociation(ex.Entity, m.Member)) { // convert singleton associations directly to OUTER APPLY projection = projection.AddOuterJoinTest(); Expression newFrom = new DbJoinExpression(DbJoinType.OuterApply, this.currentFrom, projection.Select, null); this.currentFrom = newFrom; return(projection.Projector); } return(projection); } else { Expression result = QueryBinder.BindMember(source, m.Member); MemberExpression mex = result as MemberExpression; if (mex != null && mex.Member == m.Member && mex.Expression == m.Expression) { return(m); } return(result); } }
protected virtual Expression VisitJoin(DbJoinExpression join) { Expression left = VisitSource(join.Left); Expression right = VisitSource(join.Right); Expression condition = Visit(join.Condition); return(UpdateJoin(join, join.Join, left, right, condition)); }
protected override Expression VisitProjection(DbProjectionExpression proj) { DbSelectExpression save = this.currentSelect; this.currentSelect = proj.Select; 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 DbSelectExpression newOuterSelect = (DbSelectExpression)QueryDuplicator.Duplicate(save); // remap any references to the outer select to the new alias; DbSelectExpression newInnerSelect = (DbSelectExpression)ColumnMapper.Map(proj.Select, newOuterSelect.Alias, save.Alias); // add outer-join test DbProjectionExpression newInnerProjection = new DbProjectionExpression(newInnerSelect, proj.Projector).AddOuterJoinTest(); newInnerSelect = newInnerProjection.Select; Expression newProjector = newInnerProjection.Projector; DbTableAlias newAlias = new DbTableAlias(); var pc = ColumnProjector.ProjectColumns(this.language.CanBeColumn, newProjector, newOuterSelect.Columns, newAlias, newOuterSelect.Alias, newInnerSelect.Alias); DbJoinExpression join = new DbJoinExpression(DbJoinType.OuterApply, newOuterSelect, newInnerSelect, null); DbSelectExpression joinedSelect = new DbSelectExpression(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, ((DbColumnExpression)k).Alias)); DbProjectionExpression newProjection = new DbProjectionExpression(joinedSelect, newProjector, proj.Aggregator); return(new DbClientJoinExpression(newProjection, outerKey, innerKey)); } } } else { this.isTopLevel = false; } return(base.VisitProjection(proj)); } finally { this.currentSelect = save; } }
protected override Expression VisitProjection(DbProjectionExpression proj) { DbSelectExpression save = this.currentSelect; this.currentSelect = proj.Select; 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 DbSelectExpression newOuterSelect = (DbSelectExpression)QueryDuplicator.Duplicate(save); // remap any references to the outer select to the new alias; DbSelectExpression newInnerSelect = (DbSelectExpression)ColumnMapper.Map(proj.Select, newOuterSelect.Alias, save.Alias); // add outer-join test DbProjectionExpression newInnerProjection = new DbProjectionExpression(newInnerSelect, proj.Projector).AddOuterJoinTest(); newInnerSelect = newInnerProjection.Select; Expression newProjector = newInnerProjection.Projector; DbTableAlias newAlias = new DbTableAlias(); var pc = ColumnProjector.ProjectColumns(this.language.CanBeColumn, newProjector, newOuterSelect.Columns, newAlias, newOuterSelect.Alias, newInnerSelect.Alias); DbJoinExpression join = new DbJoinExpression(DbJoinType.OuterApply, newOuterSelect, newInnerSelect, null); DbSelectExpression joinedSelect = new DbSelectExpression(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, ((DbColumnExpression)k).Alias)); DbProjectionExpression newProjection = new DbProjectionExpression(joinedSelect, newProjector, proj.Aggregator); return new DbClientJoinExpression(newProjection, outerKey, innerKey); } } } else { this.isTopLevel = false; } return base.VisitProjection(proj); } finally { this.currentSelect = save; } }
protected DbJoinExpression UpdateJoin(DbJoinExpression join, DbJoinType joinType, Expression left, Expression right, Expression condition) { if (joinType != join.Join || left != join.Left || right != join.Right || condition != join.Condition) { return(new DbJoinExpression(joinType, left, right, condition)); } return(join); }
protected override Expression VisitJoin(DbJoinExpression join) { var saveLastJoin = this.lastJoin; this.lastJoin = join.Join; join = (DbJoinExpression)base.VisitJoin(join); this.lastJoin = saveLastJoin; if (this.lastJoin != null && (join.Join == DbJoinType.CrossJoin) != (this.lastJoin == DbJoinType.CrossJoin)) { var result = this.MakeSubquery(join); return result; } return join; }
protected override Expression VisitJoin(DbJoinExpression join) { var saveLastJoin = this.lastJoin; this.lastJoin = join.Join; join = (DbJoinExpression)base.VisitJoin(join); this.lastJoin = saveLastJoin; if (this.lastJoin != null && (join.Join == DbJoinType.CrossJoin) != (this.lastJoin == DbJoinType.CrossJoin)) { var result = this.MakeSubquery(join); return(result); } return(join); }
protected virtual Expression BindSelectMany(Type resultType, Expression source, LambdaExpression collectionSelector, LambdaExpression resultSelector) { DbProjectionExpression projection = this.VisitSequence(source); this.map[collectionSelector.Parameters[0]] = projection.Projector; Expression collection = collectionSelector.Body; // check for DefaultIfEmpty bool defaultIfEmpty = false; MethodCallExpression mcs = collection as MethodCallExpression; if (mcs != null && mcs.Method.Name == "DefaultIfEmpty" && mcs.Arguments.Count == 1 && (mcs.Method.DeclaringType == typeof(Queryable) || mcs.Method.DeclaringType == typeof(Enumerable))) { collection = mcs.Arguments[0]; defaultIfEmpty = true; } DbProjectionExpression collectionProjection = (DbProjectionExpression)this.VisitSequence(collection); bool isTable = collectionProjection.Select.From is DbTableExpression; DbJoinType joinType = isTable ? DbJoinType.CrossJoin : defaultIfEmpty ? DbJoinType.OuterApply : DbJoinType.CrossApply; if (joinType == DbJoinType.OuterApply) { collectionProjection = collectionProjection.AddOuterJoinTest(); } DbJoinExpression join = new DbJoinExpression(joinType, projection.Select, collectionProjection.Select, null); var alias = this.GetNextAlias(); ProjectedColumns pc; if (resultSelector == null) { pc = this.ProjectColumns(collectionProjection.Projector, alias, projection.Select.Alias, collectionProjection.Select.Alias); } else { this.map[resultSelector.Parameters[0]] = projection.Projector; this.map[resultSelector.Parameters[1]] = collectionProjection.Projector; Expression result = this.Visit(resultSelector.Body); pc = this.ProjectColumns(result, alias, projection.Select.Alias, collectionProjection.Select.Alias); } return(new DbProjectionExpression( new DbSelectExpression(alias, pc.Columns, join, null), pc.Projector )); }
private static DbSelectExpression GetLeftMostSelect(Expression source) { DbSelectExpression select = source as DbSelectExpression; if (select != null) { return(select); } DbJoinExpression join = source as DbJoinExpression; if (join != null) { return(GetLeftMostSelect(join.Left)); } return(null); }
protected override Expression VisitJoin(DbJoinExpression join) { join = (DbJoinExpression)base.VisitJoin(join); if (join.Join == DbJoinType.CrossApply || join.Join == DbJoinType.OuterApply) { if (join.Right is DbTableExpression) { return new DbJoinExpression(DbJoinType.CrossJoin, join.Left, join.Right, null); } else { DbSelectExpression select = join.Right as DbSelectExpression; // 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)) { DbSelectExpression selectWithoutWhere = select.SetWhere(null); HashSet<DbTableAlias> referencedAliases = ReferencedAliasGatherer.Gather(selectWithoutWhere); HashSet<DbTableAlias> 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; DbJoinType jt = (where == null) ? DbJoinType.CrossJoin : (join.Join == DbJoinType.CrossApply ? DbJoinType.InnerJoin : DbJoinType.LeftOuter); return new DbJoinExpression(jt, join.Left, select, where); } } } } return join; }
protected override Expression VisitJoin(DbJoinExpression join) { join = (DbJoinExpression)base.VisitJoin(join); if (join.Join == DbJoinType.CrossApply || join.Join == DbJoinType.OuterApply) { if (join.Right is DbTableExpression) { return(new DbJoinExpression(DbJoinType.CrossJoin, join.Left, join.Right, null)); } else { DbSelectExpression select = join.Right as DbSelectExpression; // 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)) { DbSelectExpression selectWithoutWhere = select.SetWhere(null); HashSet <DbTableAlias> referencedAliases = ReferencedAliasGatherer.Gather(selectWithoutWhere); HashSet <DbTableAlias> 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; DbJoinType jt = (where == null) ? DbJoinType.CrossJoin : (join.Join == DbJoinType.CrossApply ? DbJoinType.InnerJoin : DbJoinType.LeftOuter); return(new DbJoinExpression(jt, join.Left, select, where)); } } } } return(join); }
protected override Expression VisitProjection(DbProjectionExpression proj) { if (isTopLevel) { isTopLevel = false; this.currentSelect = proj.Select; Expression 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)) { DbTableAlias newAlias = new DbTableAlias(); this.currentSelect = this.currentSelect.AddRedundantSelect(newAlias); // remap any references to the outer select to the new alias; DbSelectExpression source = (DbSelectExpression)ColumnMapper.Map(proj.Select, newAlias, this.currentSelect.Alias); // add outer-join test DbProjectionExpression pex = new DbProjectionExpression(source, proj.Projector).AddOuterJoinTest(); var pc = ColumnProjector.ProjectColumns(this.language.CanBeColumn, pex.Projector, this.currentSelect.Columns, this.currentSelect.Alias, newAlias, proj.Select.Alias); DbJoinExpression join = new DbJoinExpression(DbJoinType.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; Expression result = base.VisitProjection(proj); this.isTopLevel = saveTop; this.currentSelect = saveSelect; return(result); }
protected override Expression VisitJoin(DbJoinExpression join) { Expression result = base.VisitJoin(join); join = result as DbJoinExpression; if (join != null) { DbAliasedExpression right = join.Right as DbAliasedExpression; if (right != null) { DbAliasedExpression similarRight = (DbAliasedExpression)this.FindSimilarRight(join.Left as DbJoinExpression, join); if (similarRight != null) { this.map.Add(right.Alias, similarRight.Alias); return join.Left; } } } return result; }
protected override Expression VisitJoin(DbJoinExpression join) { // make sure order by expressions lifted up from the left side are not lost // when visiting the right side Expression left = this.VisitSource(join.Left); IList <DbOrderExpression> leftOrders = this.gatheredOrderings; this.gatheredOrderings = null; // start on the right with a clean slate Expression right = this.VisitSource(join.Right); this.PrependOrderings(leftOrders); Expression condition = this.Visit(join.Condition); if (left != join.Left || right != join.Right || condition != join.Condition) { return(new DbJoinExpression(join.Join, left, right, condition)); } return(join); }
protected override Expression VisitProjection(DbProjectionExpression proj) { if (isTopLevel) { isTopLevel = false; this.currentSelect = proj.Select; Expression 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)) { DbTableAlias newAlias = new DbTableAlias(); this.currentSelect = this.currentSelect.AddRedundantSelect(newAlias); // remap any references to the outer select to the new alias; DbSelectExpression source = (DbSelectExpression)ColumnMapper.Map(proj.Select, newAlias, this.currentSelect.Alias); // add outer-join test DbProjectionExpression pex = new DbProjectionExpression(source, proj.Projector).AddOuterJoinTest(); var pc = ColumnProjector.ProjectColumns(this.language.CanBeColumn, pex.Projector, this.currentSelect.Columns, this.currentSelect.Alias, newAlias, proj.Select.Alias); DbJoinExpression join = new DbJoinExpression(DbJoinType.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; Expression result = base.VisitProjection(proj); this.isTopLevel = saveTop; this.currentSelect = saveSelect; return result; }
protected override Expression VisitJoin(DbJoinExpression join) { Expression result = base.VisitJoin(join); join = result as DbJoinExpression; if (join != null) { DbAliasedExpression right = join.Right as DbAliasedExpression; if (right != null) { DbAliasedExpression similarRight = (DbAliasedExpression)this.FindSimilarRight(join.Left as DbJoinExpression, join); if (similarRight != null) { this.map.Add(right.Alias, similarRight.Alias); return(join.Left); } } } return(result); }
protected override Expression VisitJoin(DbJoinExpression join) { join = (DbJoinExpression)base.VisitJoin(join); if (join.Join == DbJoinType.CrossJoin && this.currentWhere != null) { // try to figure out which parts of the current where expression can be used for a join condition var declaredLeft = DeclaredAliasGatherer.Gather(join.Left); var declaredRight = DeclaredAliasGatherer.Gather(join.Right); var declared = new HashSet <DbTableAlias>(declaredLeft.Union(declaredRight)); var exprs = this.currentWhere.Split(ExpressionType.And, ExpressionType.AndAlso); var good = exprs.Where(e => CanBeJoinCondition(e, declaredLeft, declaredRight, declared)).ToList(); if (good.Count > 0) { var condition = good.Join(ExpressionType.And); join = this.UpdateJoin(join, DbJoinType.InnerJoin, join.Left, join.Right, condition); var newWhere = exprs.Where(e => !good.Contains(e)).Join(ExpressionType.And); this.currentWhere = newWhere; } } return(join); }
protected override Expression VisitJoin(DbJoinExpression join) { join = (DbJoinExpression)base.VisitJoin(join); if (join.Join == DbJoinType.CrossJoin && this.currentWhere != null) { // try to figure out which parts of the current where expression can be used for a join condition var declaredLeft = DeclaredAliasGatherer.Gather(join.Left); var declaredRight = DeclaredAliasGatherer.Gather(join.Right); var declared = new HashSet<DbTableAlias>(declaredLeft.Union(declaredRight)); var exprs = this.currentWhere.Split(ExpressionType.And, ExpressionType.AndAlso); var good = exprs.Where(e => CanBeJoinCondition(e, declaredLeft, declaredRight, declared)).ToList(); if (good.Count > 0) { var condition = good.Join(ExpressionType.And); join = this.UpdateJoin(join, DbJoinType.InnerJoin, join.Left, join.Right, condition); var newWhere = exprs.Where(e => !good.Contains(e)).Join(ExpressionType.And); this.currentWhere = newWhere; } } return join; }
protected virtual Expression BindJoin(Type resultType, Expression outerSource, Expression innerSource, LambdaExpression outerKey, LambdaExpression innerKey, LambdaExpression resultSelector) { DbProjectionExpression outerProjection = this.VisitSequence(outerSource); DbProjectionExpression innerProjection = this.VisitSequence(innerSource); this.map[outerKey.Parameters[0]] = outerProjection.Projector; Expression outerKeyExpr = this.Visit(outerKey.Body); this.map[innerKey.Parameters[0]] = innerProjection.Projector; Expression innerKeyExpr = this.Visit(innerKey.Body); this.map[resultSelector.Parameters[0]] = outerProjection.Projector; this.map[resultSelector.Parameters[1]] = innerProjection.Projector; Expression resultExpr = this.Visit(resultSelector.Body); DbJoinExpression join = new DbJoinExpression(DbJoinType.InnerJoin, outerProjection.Select, innerProjection.Select, outerKeyExpr.Equal(innerKeyExpr)); var alias = this.GetNextAlias(); ProjectedColumns pc = this.ProjectColumns(resultExpr, alias, outerProjection.Select.Alias, innerProjection.Select.Alias); return(new DbProjectionExpression( new DbSelectExpression(alias, pc.Columns, join, null), pc.Projector )); }
private Expression FindSimilarRight(DbJoinExpression join, DbJoinExpression compareTo) { if (join == null) return null; if (join.Join == compareTo.Join) { if (join.Right.NodeType == compareTo.Right.NodeType && DbExpressionComparer.AreEqual(join.Right, compareTo.Right)) { if (join.Condition == compareTo.Condition) return join.Right; var scope = new ScopedDictionary<DbTableAlias, DbTableAlias>(null); scope.Add(((DbAliasedExpression)join.Right).Alias, ((DbAliasedExpression)compareTo.Right).Alias); if (DbExpressionComparer.AreEqual(null, scope, join.Condition, compareTo.Condition)) return join.Right; } } Expression result = FindSimilarRight(join.Left as DbJoinExpression, compareTo); if (result == null) { result = FindSimilarRight(join.Right as DbJoinExpression, compareTo); } return result; }
protected override Expression VisitJoin(DbJoinExpression join) { if (join.Join == DbJoinType.SingletonLeftOuter) { // first visit right side w/o looking at condition Expression right = this.Visit(join.Right); DbAliasedExpression ax = right as DbAliasedExpression; if (ax != null && !this.allColumnsUsed.ContainsKey(ax.Alias)) { // if nothing references the alias on the right, then the join is redundant return this.Visit(join.Left); } // otherwise do it the right way Expression cond = this.Visit(join.Condition); Expression left = this.Visit(join.Left); right = this.Visit(join.Right); return this.UpdateJoin(join, join.Join, left, right, cond); } else { // visit join in reverse order Expression condition = this.Visit(join.Condition); Expression right = this.VisitSource(join.Right); Expression left = this.VisitSource(join.Left); return this.UpdateJoin(join, join.Join, left, right, condition); } }
protected virtual Expression BindSelectMany(Type resultType, Expression source, LambdaExpression collectionSelector, LambdaExpression resultSelector) { DbProjectionExpression projection = this.VisitSequence(source); this.map[collectionSelector.Parameters[0]] = projection.Projector; Expression collection = collectionSelector.Body; // check for DefaultIfEmpty bool defaultIfEmpty = false; MethodCallExpression mcs = collection as MethodCallExpression; if (mcs != null && mcs.Method.Name == "DefaultIfEmpty" && mcs.Arguments.Count == 1 && (mcs.Method.DeclaringType == typeof(Queryable) || mcs.Method.DeclaringType == typeof(Enumerable))) { collection = mcs.Arguments[0]; defaultIfEmpty = true; } DbProjectionExpression collectionProjection = (DbProjectionExpression)this.VisitSequence(collection); bool isTable = collectionProjection.Select.From is DbTableExpression; DbJoinType joinType = isTable ? DbJoinType.CrossJoin : defaultIfEmpty ? DbJoinType.OuterApply : DbJoinType.CrossApply; if (joinType == DbJoinType.OuterApply) { collectionProjection = collectionProjection.AddOuterJoinTest(); } DbJoinExpression join = new DbJoinExpression(joinType, projection.Select, collectionProjection.Select, null); var alias = this.GetNextAlias(); ProjectedColumns pc; if (resultSelector == null) { pc = this.ProjectColumns(collectionProjection.Projector, alias, projection.Select.Alias, collectionProjection.Select.Alias); } else { this.map[resultSelector.Parameters[0]] = projection.Projector; this.map[resultSelector.Parameters[1]] = collectionProjection.Projector; Expression result = this.Visit(resultSelector.Body); pc = this.ProjectColumns(result, alias, projection.Select.Alias, collectionProjection.Select.Alias); } return new DbProjectionExpression( new DbSelectExpression(alias, pc.Columns, join, null), pc.Projector ); }
protected DbJoinExpression UpdateJoin(DbJoinExpression join, DbJoinType joinType, Expression left, Expression right, Expression condition) { if (joinType != join.Join || left != join.Left || right != join.Right || condition != join.Condition) return new DbJoinExpression(joinType, left, right, condition); return join; }
protected virtual Expression VisitJoin(DbJoinExpression join) { Expression left = VisitSource(join.Left); Expression right = VisitSource(join.Right); Expression condition = Visit(join.Condition); return UpdateJoin(join, join.Join, left, right, condition); }
protected virtual Expression BindJoin(Type resultType, Expression outerSource, Expression innerSource, LambdaExpression outerKey, LambdaExpression innerKey, LambdaExpression resultSelector) { DbProjectionExpression outerProjection = this.VisitSequence(outerSource); DbProjectionExpression innerProjection = this.VisitSequence(innerSource); this.map[outerKey.Parameters[0]] = outerProjection.Projector; Expression outerKeyExpr = this.Visit(outerKey.Body); this.map[innerKey.Parameters[0]] = innerProjection.Projector; Expression innerKeyExpr = this.Visit(innerKey.Body); this.map[resultSelector.Parameters[0]] = outerProjection.Projector; this.map[resultSelector.Parameters[1]] = innerProjection.Projector; Expression resultExpr = this.Visit(resultSelector.Body); DbJoinExpression join = new DbJoinExpression(DbJoinType.InnerJoin, outerProjection.Select, innerProjection.Select, outerKeyExpr.Equal(innerKeyExpr)); var alias = this.GetNextAlias(); ProjectedColumns pc = this.ProjectColumns(resultExpr, alias, outerProjection.Select.Alias, innerProjection.Select.Alias); return new DbProjectionExpression( new DbSelectExpression(alias, pc.Columns, join, null), pc.Projector ); }
protected virtual bool CompareJoin(DbJoinExpression a, DbJoinExpression b) { if (a.Join != b.Join || !Compare(a.Left, b.Left)) return false; if (a.Join == DbJoinType.CrossApply || a.Join == DbJoinType.OuterApply) { ScopedDictionary<DbTableAlias, DbTableAlias> save = _aliasScope; try { _aliasScope = new ScopedDictionary<DbTableAlias, DbTableAlias>(_aliasScope); MapAliases(a.Left, b.Left); return Compare(a.Right, b.Right) && Compare(a.Condition, b.Condition); } finally { _aliasScope = save; } } else { return Compare(a.Right, b.Right) && Compare(a.Condition, b.Condition); } }
protected override Expression VisitJoin(DbJoinExpression join) { // make sure order by expressions lifted up from the left side are not lost // when visiting the right side Expression left = this.VisitSource(join.Left); IList<DbOrderExpression> leftOrders = this.gatheredOrderings; this.gatheredOrderings = null; // start on the right with a clean slate Expression right = this.VisitSource(join.Right); this.PrependOrderings(leftOrders); Expression condition = this.Visit(join.Condition); if (left != join.Left || right != join.Right || condition != join.Condition) { return new DbJoinExpression(join.Join, left, right, condition); } return join; }
protected override Expression VisitJoin(DbJoinExpression join) { this.VisitJoinLeft(join.Left); this.WriteLine(Indentation.Same); switch (join.Join) { case DbJoinType.CrossJoin: this.Write("CROSS JOIN "); break; case DbJoinType.InnerJoin: this.Write("INNER JOIN "); break; case DbJoinType.CrossApply: this.Write("CROSS APPLY "); break; case DbJoinType.OuterApply: this.Write("OUTER APPLY "); break; case DbJoinType.LeftOuter: case DbJoinType.SingletonLeftOuter: this.Write("LEFT OUTER JOIN "); break; } this.VisitJoinRight(join.Right); if (join.Condition != null) { this.WriteLine(Indentation.Inner); this.Write("ON "); this.VisitPredicate(join.Condition); this.Indent(Indentation.Outer); } return join; }