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)); } SelectExpression right = join.Right as SelectExpression; if ((((right != null) && (right.Take == null)) && ((right.Skip == null) && !AggregateChecker.HasAggregates(right))) && ((right.GroupBy == null) || (right.GroupBy.Count == 0))) { SelectExpression source = right.SetWhere(null); HashSet <TableAlias> set = ReferencedAliasGatherer.Gather(source); HashSet <TableAlias> other = DeclaredAliasGatherer.Gather(join.Left); set.IntersectWith(other); if (set.Count == 0) { Expression where = right.Where; right = source; ProjectedColumns columns = ColumnProjector.ProjectColumns(this.language, where, right.Columns, right.Alias, DeclaredAliasGatherer.Gather(right.From)); right = right.SetColumns(columns.Columns); where = columns.Projector; return(new JoinExpression((where == null) ? JoinType.CrossJoin : ((join.Join == JoinType.CrossApply) ? JoinType.InnerJoin : JoinType.LeftOuter), join.Left, right, where)); } } } return(join); }
protected override Expression VisitJoin(JoinExpression join) { join = (JoinExpression)base.VisitJoin(join); if ((join.Join == JoinType.CrossJoin) && (this.currentWhere != null)) { Func <Expression, bool> predicate = null; HashSet <TableAlias> declaredLeft = DeclaredAliasGatherer.Gather(join.Left); HashSet <TableAlias> declaredRight = DeclaredAliasGatherer.Gather(join.Right); HashSet <TableAlias> declared = new HashSet <TableAlias>(declaredLeft.Union <TableAlias>(declaredRight)); Expression[] source = this.currentWhere.Split(new ExpressionType[] { ExpressionType.And, ExpressionType.AndAlso }); List <Expression> good = (from e in source where this.CanBeJoinCondition(e, declaredLeft, declaredRight, declared) select e).ToList <Expression>(); if (good.Count <= 0) { return(join); } Expression condition = good.Join(ExpressionType.And); join = base.UpdateJoin(join, JoinType.InnerJoin, join.Left, join.Right, condition); if (predicate == null) { predicate = e => !good.Contains(e); } Expression expression2 = source.Where <Expression>(predicate).Join(ExpressionType.And); this.currentWhere = expression2; } return(join); }
protected override Expression VisitSelect(SelectExpression select) { Expression expression; bool isOuterMostSelect = this.isOuterMostSelect; try { this.isOuterMostSelect = false; select = (SelectExpression)base.VisitSelect(select); bool flag2 = (select.OrderBy != null) && (select.OrderBy.Count > 0); bool flag3 = (select.GroupBy != null) && (select.GroupBy.Count > 0); bool flag4 = (isOuterMostSelect || (select.Take != null)) || (select.Skip != null); bool flag5 = ((flag4 && !flag3) && !select.IsDistinct) && !AggregateChecker.HasAggregates(select); if (flag2) { this.PrependOrderings(select.OrderBy); } if (select.IsReverse) { this.ReverseOrderings(); } IEnumerable <OrderExpression> orderBy = null; if (flag5) { orderBy = this.gatheredOrderings; } else if (flag4) { orderBy = select.OrderBy; } bool flag6 = (!isOuterMostSelect && !flag3) && !select.IsDistinct; ReadOnlyCollection <ColumnDeclaration> columns = select.Columns; if (this.gatheredOrderings != null) { if (flag6) { HashSet <TableAlias> existingAliases = DeclaredAliasGatherer.Gather(select.From); BindResult result = this.RebindOrderings(this.gatheredOrderings, select.Alias, existingAliases, select.Columns); this.gatheredOrderings = null; this.PrependOrderings(result.Orderings); columns = result.Columns; } else { this.gatheredOrderings = null; } } if (((orderBy != select.OrderBy) || (columns != select.Columns)) || select.IsReverse) { select = new SelectExpression(select.Alias, columns, select.From, select.Where, orderBy, select.GroupBy, select.IsDistinct, select.Skip, select.Take, false); } expression = select; } finally { this.isOuterMostSelect = isOuterMostSelect; } return(expression); }
private void MapAliases(Expression a, Expression b) { TableAlias[] aliasArray = DeclaredAliasGatherer.Gather(a).ToArray <TableAlias>(); TableAlias[] aliasArray2 = DeclaredAliasGatherer.Gather(b).ToArray <TableAlias>(); int index = 0; int length = aliasArray.Length; while (index < length) { this.aliasScope.Add(aliasArray[index], aliasArray2[index]); index++; } }
private Expression MakeSubquery(Expression expression) { TableAlias alias = new TableAlias(); HashSet <TableAlias> set = DeclaredAliasGatherer.Gather(expression); List <ColumnDeclaration> columns = new List <ColumnDeclaration>(); foreach (TableAlias alias2 in set) { foreach (ColumnExpression expression2 in this.columns[alias2]) { ColumnDeclaration item = new ColumnDeclaration(columns.GetAvailableColumnName(expression2.Name), expression2, expression2.QueryType); columns.Add(item); ColumnExpression expression3 = new ColumnExpression(expression2.Type, expression2.QueryType, alias, expression2.Name); this.map.Add(expression2, expression3); } } return(new SelectExpression(alias, columns, expression, null)); }
public virtual Expression GetOuterJoinTest(SelectExpression select) { List <ColumnExpression> list = JoinColumnGatherer.Gather(DeclaredAliasGatherer.Gather(select.From), select).ToList <ColumnExpression>(); if (list.Count > 0) { foreach (ColumnExpression expression in list) { foreach (ColumnDeclaration declaration in select.Columns) { if (expression.Equals(declaration.Expression)) { return(expression); } } } return(list[0]); } return(Expression.Constant(1, typeof(int?))); }