コード例 #1
0
        protected internal override Expression VisitJoin(JoinExpression join)
        {
            if (join.Condition != null)
            {
                GetColumnCollector(join.KnownAliases).Visit(join.Condition);
            }
            else if (join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply)
            {
                GetColumnCollector(join.Left.KnownAliases).Visit(join.Right);
            }

            SourceExpression left      = this.VisitSource(join.Left);
            SourceExpression right     = this.VisitSource(join.Right);
            Expression?      condition = this.Visit(join.Condition);

            if (left != join.Left || right != join.Right || condition != join.Condition)
            {
                return(new JoinExpression(join.JoinType, left, right, condition));
            }
            return(join);
        }
コード例 #2
0
            private static IEnumerable <ColumnExpression> KeysJoin(JoinExpression join)
            {
                switch (join.JoinType)
                {
                case JoinType.SingleRowLeftOuterJoin:
                    return(Keys(join.Left));

                case JoinType.CrossJoin:
                case JoinType.InnerJoin:
                case JoinType.CrossApply:
                case JoinType.OuterApply:
                case JoinType.LeftOuterJoin:
                case JoinType.RightOuterJoin:
                case JoinType.FullOuterJoin:
                    return(Keys(join.Left).Concat(Keys(join.Right)));

                default:
                    break;
                }

                throw new InvalidOperationException("Unexpected Join Type");
            }
コード例 #3
0
        protected internal override Expression VisitJoin(JoinExpression join)
        {
            if (join.JoinType == JoinType.SingleRowLeftOuterJoin)
            {
                var source = join.Right as SourceWithAliasExpression;

                var hs = allColumnsUsed.TryGetC(source.Alias);

                if (hs == null || hs.Count == 0)
                {
                    return(Visit(join.Left));
                }
            }

            if (join.JoinType == JoinType.OuterApply || join.JoinType == JoinType.LeftOuterJoin)
            {
                var sql = join.Right as SelectExpression;

                if (sql != null && sql.IsOneRow())
                {
                    var hs = allColumnsUsed.TryGetC(sql.Alias);
                    if (hs == null || hs.Count == 0)
                    {
                        return(Visit(join.Left));
                    }
                }
            }

            // visit join in reverse order
            Expression       condition = this.Visit(join.Condition);
            SourceExpression right     = this.VisitSource(join.Right);
            SourceExpression left      = this.VisitSource(join.Left);

            if (left != join.Left || right != join.Right || condition != join.Condition)
            {
                return(new JoinExpression(join.JoinType, left, right, condition));
            }
            return(join);
        }
コード例 #4
0
        protected internal override Expression VisitJoin(JoinExpression join)
        {
            SourceExpression left      = this.VisitSource(join.Left);
            SourceExpression right     = this.VisitSource(join.Right);
            Expression?      condition = this.Visit(join.Condition);

            if (join.JoinType == JoinType.CrossApply || join.JoinType == JoinType.OuterApply)
            {
                if (right is TableExpression)
                {
                    return(new JoinExpression(join.JoinType == JoinType.OuterApply ? JoinType.LeftOuterJoin : JoinType.InnerJoin, left, right,
                                              Schema.Current.Settings.IsPostgres ? (Expression) new SqlConstantExpression(true) :
                                              Expression.Equal(new SqlConstantExpression(1), new SqlConstantExpression(1))));
                }
            }

            if (left != join.Left || right != join.Right || condition != join.Condition)
            {
                return(new JoinExpression(join.JoinType, left, right, condition));
            }
            return(join);
        }