Exemplo n.º 1
0
            private void CheckJoinCondition(SqlExpression expr)
            {
                switch (expr.NodeType)
                {
                case SqlNodeType.And: {
                    SqlBinary b = (SqlBinary)expr;
                    CheckJoinCondition(b.Left);
                    CheckJoinCondition(b.Right);
                    break;
                }

                case SqlNodeType.EQ:
                case SqlNodeType.EQ2V: {
                    SqlBinary    b       = (SqlBinary)expr;
                    SqlColumnRef crLeft  = b.Left as SqlColumnRef;
                    SqlColumnRef crRight = b.Right as SqlColumnRef;
                    if (crLeft != null && crRight != null)
                    {
                        SqlColumn cLeft  = crLeft.GetRootColumn();
                        SqlColumn cRight = crRight.GetRootColumn();
                        this.map[cLeft]  = cRight;
                        this.map[cRight] = cLeft;
                    }
                    break;
                }
                }
            }
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     if (expressionSink != null)
     {
         expressionSink.ReferencedExpressions.Add(cref.Column);
     }
     return(cref);
 }
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     if (this.ingoreExternalRefs && !this.nodeMap.ContainsKey(cref.Column))
     {
         return(cref);
     }
     return(new SqlColumnRef((SqlColumn)this.Visit(cref.Column)));
 }
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     if (cref.Column.Name == null && this.lastName != null)
     {
         cref.Column.Name = this.lastName;
     }
     return(cref);
 }
Exemplo n.º 5
0
            internal SqlColumn GetOriginatingColumn(SqlColumn col)
            {
                SqlColumnRef cref = col.Expression as SqlColumnRef;

                if (cref != null)
                {
                    return(this.GetOriginatingColumn(cref.Column));
                }
                return(col);
            }
Exemplo n.º 6
0
            internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
            {
                SqlColumnRef result = this.BubbleUp(cref);

                if (result == null)
                {
                    throw Error.ColumnReferencedIsNotInScope(GetColumnName(cref.Column));
                }
                return(result);
            }
Exemplo n.º 7
0
            internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
            {
                SqlExpression result = base.VisitColumnRef(cref);

                if (result == cref)   // must be external
                {
                    return(ExtractParameter(result));
                }
                return(result);
            }
Exemplo n.º 8
0
                internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
                {
                    SqlExpression literal = this.GetLiteralValue(cref);

                    if (literal != null)
                    {
                        return(literal);
                    }
                    return(cref);
                }
Exemplo n.º 9
0
            internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
            {
                SqlColumn mapped;

                if (this.map.TryGetValue(cref.Column, out mapped))
                {
                    return(new SqlColumnRef(mapped));
                }
                return(cref);
            }
Exemplo n.º 10
0
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     if (this.aliasesToCheck.Contains(cref.Column.Alias))
     {
         this.hasDependency = true;
     }
     else if (cref.Column.Expression != null)
     {
         this.Visit(cref.Column.Expression);
     }
     return(cref);
 }
Exemplo n.º 11
0
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     if (this.parent.aliases.Contains(cref.Column.Alias))
     {
         this.parent.referencesAny = true;
     }
     else if (cref.Column.Expression != null)
     {
         this.Visit(cref.Column.Expression);
     }
     return(cref);
 }
Exemplo n.º 12
0
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     if (!this.columns.Contains(cref.Column))
     {
         this.columns.Add(cref.Column);
         if (cref.Column.Expression != null)
         {
             this.Visit(cref.Column.Expression);
         }
     }
     return(cref);
 }
Exemplo n.º 13
0
                internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
                {
                    SqlColumn c = this.FindColumn(this.row.Columns, cref.Column);

                    if (c == null)
                    {
                        return(MakeFlattenedColumn(cref, null));
                    }
                    else
                    {
                        return(new SqlColumnRef(c));
                    }
                }
Exemplo n.º 14
0
            internal override SqlSelect  VisitSelect(SqlSelect select)
            {
                base.VisitSelect(select);

                // enforce exact ordering of columns in union selects
                SqlUnion union = this.GetUnion(select.From);

                if (union != null)
                {
                    SqlSelect sleft  = union.Left as SqlSelect;
                    SqlSelect sright = union.Right as SqlSelect;
                    if (sleft != null & sright != null)
                    {
                        // preset ordinals to high values (so any unreachable column definition is ordered last)
                        for (int i = 0, n = sleft.Row.Columns.Count; i < n; i++)
                        {
                            sleft.Row.Columns[i].Ordinal = select.Row.Columns.Count + i;
                        }
                        for (int i = 0, n = sright.Row.Columns.Count; i < n; i++)
                        {
                            sright.Row.Columns[i].Ordinal = select.Row.Columns.Count + i;
                        }
                        // next assign ordinals to all direct columns in subselects
                        for (int i = 0, n = select.Row.Columns.Count; i < n; i++)
                        {
                            SqlExprSet es = select.Row.Columns[i].Expression as SqlExprSet;
                            if (es != null)
                            {
                                for (int e = 0, en = es.Expressions.Count; e < en; e++)
                                {
                                    SqlColumnRef cr = es.Expressions[e] as SqlColumnRef;
                                    if (cr != null && e >= select.Row.Columns.Count)
                                    {
                                        cr.Column.Ordinal = i;
                                    }
                                }
                            }
                        }
                        // next sort columns in left & right subselects
                        Comparison <SqlColumn> comp = (x, y) => x.Ordinal - y.Ordinal;
                        sleft.Row.Columns.Sort(comp);
                        sright.Row.Columns.Sort(comp);
                    }
                }

                return(select);
            }
Exemplo n.º 15
0
 private static SqlColumn GetBaseColumn(SqlColumnRef cref)
 {
     while (cref != null && cref.Column.Expression != null)
     {
         SqlColumnRef cr = cref.Column.Expression as SqlColumnRef;
         if (cr != null)
         {
             cref = cr;
             continue;
         }
         else
         {
             break;
         }
     }
     return(cref.Column);
 }
Exemplo n.º 16
0
        internal bool RefersToColumn(SqlExpression exp, SqlColumn col)
        {
#if DEBUG
            try {
                refersDepth++;
                System.Diagnostics.Debug.Assert(refersDepth < 20);
#endif
            if (exp != null)
            {
                switch (exp.NodeType)
                {
                case SqlNodeType.Column:
                    return(exp == col || this.RefersToColumn(((SqlColumn)exp).Expression, col));

                case SqlNodeType.ColumnRef:
                    SqlColumnRef cref = (SqlColumnRef)exp;
                    return(cref.Column == col || this.RefersToColumn(cref.Column.Expression, col));

                case SqlNodeType.ExprSet:
                    SqlExprSet set = (SqlExprSet)exp;
                    for (int i = 0, n = set.Expressions.Count; i < n; i++)
                    {
                        if (this.RefersToColumn(set.Expressions[i], col))
                        {
                            return(true);
                        }
                    }
                    break;

                case SqlNodeType.OuterJoinedValue:
                    return(this.RefersToColumn(((SqlUnary)exp).Operand, col));
                }
            }

            return(false);

#if DEBUG
        }

        finally {
            refersDepth--;
        }
#endif
        }
Exemplo n.º 17
0
 private SqlColumnRef BubbleUp(SqlColumnRef cref)
 {
     for (Scope s = this.CurrentScope; s != null; s = s.ContainingScope)
     {
         if (s.Source != null)
         {
             SqlColumn found = this.bubbler.BubbleUp(cref.Column, s.Source);
             if (found != null)
             {
                 if (found != cref.Column)
                 {
                     return(new SqlColumnRef(found));
                 }
                 return(cref);
             }
         }
     }
     return(null);
 }
Exemplo n.º 18
0
            internal bool AreEquivalent(SqlExpression e1, SqlExpression e2)
            {
                if (SqlComparer.AreEqual(e1, e2))
                {
                    return(true);
                }

                SqlColumnRef cr1 = e1 as SqlColumnRef;
                SqlColumnRef cr2 = e2 as SqlColumnRef;

                if (cr1 != null && cr2 != null)
                {
                    SqlColumn c1 = cr1.GetRootColumn();
                    SqlColumn c2 = cr2.GetRootColumn();
                    SqlColumn r;
                    return(this.map.TryGetValue(c1, out r) && r == c2);
                }

                return(false);
            }
Exemplo n.º 19
0
 internal override SqlSelect VisitSelect(SqlSelect select)
 {
     if (IsTrivialSelect(select))
     {
         SqlSelect aselect = (SqlSelect)((SqlAlias)select.From).Node;
         // build up a column map, so we can rewrite the top-level selection expression
         Dictionary <SqlColumn, SqlColumnRef> map = new Dictionary <SqlColumn, SqlColumnRef>();
         foreach (SqlColumn c in select.Row.Columns)
         {
             SqlColumnRef cref = (SqlColumnRef)c.Expression;
             map.Add(c, cref);
             // push the interesting column names down (non null)
             if (!string.IsNullOrEmpty(c.Name))
             {
                 cref.Column.Name = c.Name;
             }
         }
         aselect.Selection = new ColumnMapper(map).VisitExpression(select.Selection);
         return(aselect);
     }
     return(select);
 }
Exemplo n.º 20
0
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     if (cref.Column.Alias != null && this.removedMap.ContainsKey(cref.Column.Alias))
     {
         SqlColumnRef c = cref.Column.Expression as SqlColumnRef;
         if (c != null)
         {
             //The following code checks for cases where there are differences between the type returned
             //by a ColumnRef and the column that refers to it.  This situation can occur when conversions
             //are optimized out of the SQL node tree.  As mentioned in the SetClrType comments this is not
             //an operation that can have adverse effects and should only be used in limited cases, such as
             //this one.
             if (c.ClrType != cref.ClrType)
             {
                 c.SetClrType(cref.ClrType);
                 return(this.VisitColumnRef(c));
             }
         }
         return(c);
     }
     return(cref);
 }
Exemplo n.º 21
0
        internal static string DiscoverName(SqlExpression e)
        {
            if (e != null)
            {
                switch (e.NodeType)
                {
                case SqlNodeType.Column:
                    return(DiscoverName(((SqlColumn)e).Expression));

                case SqlNodeType.ColumnRef:
                    SqlColumnRef cref = (SqlColumnRef)e;
                    if (cref.Column.Name != null)
                    {
                        return(cref.Column.Name);
                    }
                    return(DiscoverName(cref.Column));

                case SqlNodeType.ExprSet:
                    SqlExprSet eset = (SqlExprSet)e;
                    return(DiscoverName(eset.Expressions[0]));
                }
            }
            return("value");
        }
Exemplo n.º 22
0
 internal virtual SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     return(cref);
 }
Exemplo n.º 23
0
        internal static bool?CanBeNull(SqlExpression expr)
        {
            switch (expr.NodeType)
            {
            case SqlNodeType.ExprSet:
                SqlExprSet exprSet = (SqlExprSet)expr;
                return(CanBeNull(exprSet.Expressions));

            case SqlNodeType.SimpleCase:
                SqlSimpleCase sc = (SqlSimpleCase)expr;
                return(CanBeNull(sc.Whens.Select(w => w.Value)));

            case SqlNodeType.Column:
                SqlColumn col = (SqlColumn)expr;
                if (col.MetaMember != null)
                {
                    return(col.MetaMember.CanBeNull);
                }
                else if (col.Expression != null)
                {
                    return(CanBeNull(col.Expression));
                }
                return(null);     // Don't know.

            case SqlNodeType.ColumnRef:
                SqlColumnRef cref = (SqlColumnRef)expr;
                return(CanBeNull(cref.Column));

            case SqlNodeType.Value:
                return(((SqlValue)expr).Value == null);

            case SqlNodeType.New:
            case SqlNodeType.Multiset:
            case SqlNodeType.Grouping:
            case SqlNodeType.DiscriminatedType:
            case SqlNodeType.IsNotNull:     // IsNull\IsNotNull always return true or false and can never return NULL.
            case SqlNodeType.IsNull:
            case SqlNodeType.Exists:
                return(false);

            case SqlNodeType.Add:
            case SqlNodeType.Sub:
            case SqlNodeType.Mul:
            case SqlNodeType.Div:
            case SqlNodeType.Mod:
            case SqlNodeType.BitAnd:
            case SqlNodeType.BitOr:
            case SqlNodeType.BitXor:
            case SqlNodeType.Concat: {
                SqlBinary bop   = (SqlBinary)expr;
                bool?     left  = CanBeNull(bop.Left);
                bool?     right = CanBeNull(bop.Right);
                return((left != false) || (right != false));
            }

            case SqlNodeType.Negate:
            case SqlNodeType.BitNot: {
                SqlUnary uop = (SqlUnary)expr;
                return(CanBeNull(uop.Operand));
            }

            case SqlNodeType.Lift: {
                SqlLift lift = (SqlLift)expr;
                return(CanBeNull(lift.Expression));
            }

            case SqlNodeType.OuterJoinedValue:
                return(true);

            default:
                return(null);    // Don't know.
            }
        }
Exemplo n.º 24
0
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     this.referenceMap[cref.Column] = cref.Column;
     return(cref);
 }
Exemplo n.º 25
0
            internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
            {
                Visit(cref.Column);

                return(base.VisitColumnRef(cref));
            }
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     this.VisitColumn(cref.Column); // Travel through column references
     return(cref);
 }
Exemplo n.º 27
0
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     VisitAliasConsumed(cref.Column.Alias);
     return(cref);
 }
Exemplo n.º 28
0
 internal override SqlExpression VisitColumnRef(SqlColumnRef cref)
 {
     return(cref);
 }
Exemplo n.º 29
0
        internal static bool AreEqual(SqlNode node1, SqlNode node2)
        {
            if (node1 == node2)
            {
                return(true);
            }
            if (node1 == null || node2 == null)
            {
                return(false);
            }

            if (node1.NodeType == SqlNodeType.SimpleCase)
            {
                node1 = UnwrapTrivialCaseExpression((SqlSimpleCase)node1);
            }

            if (node2.NodeType == SqlNodeType.SimpleCase)
            {
                node2 = UnwrapTrivialCaseExpression((SqlSimpleCase)node2);
            }

            if (node1.NodeType != node2.NodeType)
            {
                // allow expression sets to compare against single expressions
                if (node1.NodeType == SqlNodeType.ExprSet)
                {
                    SqlExprSet eset = (SqlExprSet)node1;
                    for (int i = 0, n = eset.Expressions.Count; i < n; i++)
                    {
                        if (AreEqual(eset.Expressions[i], node2))
                        {
                            return(true);
                        }
                    }
                }
                else if (node2.NodeType == SqlNodeType.ExprSet)
                {
                    SqlExprSet eset = (SqlExprSet)node2;
                    for (int i = 0, n = eset.Expressions.Count; i < n; i++)
                    {
                        if (AreEqual(node1, eset.Expressions[i]))
                        {
                            return(true);
                        }
                    }
                }
                return(false);
            }
            if (node1.Equals(node2))
            {
                return(true);
            }

            switch (node1.NodeType)
            {
            case SqlNodeType.Not:
            case SqlNodeType.Not2V:
            case SqlNodeType.Negate:
            case SqlNodeType.BitNot:
            case SqlNodeType.IsNull:
            case SqlNodeType.IsNotNull:
            case SqlNodeType.Count:
            case SqlNodeType.Max:
            case SqlNodeType.Min:
            case SqlNodeType.Sum:
            case SqlNodeType.Avg:
            case SqlNodeType.Stddev:
            case SqlNodeType.ValueOf:
            case SqlNodeType.OuterJoinedValue:
            case SqlNodeType.ClrLength:
                return(AreEqual(((SqlUnary)node1).Operand, ((SqlUnary)node2).Operand));

            case SqlNodeType.Add:
            case SqlNodeType.Sub:
            case SqlNodeType.Mul:
            case SqlNodeType.Div:
            case SqlNodeType.Mod:
            case SqlNodeType.BitAnd:
            case SqlNodeType.BitOr:
            case SqlNodeType.BitXor:
            case SqlNodeType.And:
            case SqlNodeType.Or:
            case SqlNodeType.GE:
            case SqlNodeType.GT:
            case SqlNodeType.LE:
            case SqlNodeType.LT:
            case SqlNodeType.EQ:
            case SqlNodeType.NE:
            case SqlNodeType.EQ2V:
            case SqlNodeType.NE2V:
            case SqlNodeType.Concat:
                SqlBinary firstNode  = (SqlBinary)node1;
                SqlBinary secondNode = (SqlBinary)node2;
                return(AreEqual(firstNode.Left, secondNode.Left) &&
                       AreEqual(firstNode.Right, secondNode.Right));

            case SqlNodeType.Convert:
            case SqlNodeType.Treat: {
                SqlUnary sun1 = (SqlUnary)node1;
                SqlUnary sun2 = (SqlUnary)node2;
                return(sun1.ClrType == sun2.ClrType && sun1.SqlType == sun2.SqlType && AreEqual(sun1.Operand, sun2.Operand));
            }

            case SqlNodeType.Between: {
                SqlBetween b1 = (SqlBetween)node1;
                SqlBetween b2 = (SqlBetween)node1;
                return(AreEqual(b1.Expression, b2.Expression) &&
                       AreEqual(b1.Start, b2.Start) &&
                       AreEqual(b1.End, b2.End));
            }

            case SqlNodeType.Parameter:
                return(node1 == node2);

            case SqlNodeType.Alias:
                return(AreEqual(((SqlAlias)node1).Node, ((SqlAlias)node2).Node));

            case SqlNodeType.AliasRef:
                return(AreEqual(((SqlAliasRef)node1).Alias, ((SqlAliasRef)node2).Alias));

            case SqlNodeType.Column:
                SqlColumn col1 = (SqlColumn)node1;
                SqlColumn col2 = (SqlColumn)node2;
                return(col1 == col2 || (col1.Expression != null && col2.Expression != null && AreEqual(col1.Expression, col2.Expression)));

            case SqlNodeType.Table:
                return(((SqlTable)node1).MetaTable == ((SqlTable)node2).MetaTable);

            case SqlNodeType.Member:
                return((((SqlMember)node1).Member == ((SqlMember)node2).Member) &&
                       AreEqual(((SqlMember)node1).Expression, ((SqlMember)node2).Expression));

            case SqlNodeType.ColumnRef:
                SqlColumnRef cref1 = (SqlColumnRef)node1;
                SqlColumnRef cref2 = (SqlColumnRef)node2;
                return(GetBaseColumn(cref1) == GetBaseColumn(cref2));

            case SqlNodeType.Value:
                return(Object.Equals(((SqlValue)node1).Value, ((SqlValue)node2).Value));

            case SqlNodeType.TypeCase: {
                SqlTypeCase c1 = (SqlTypeCase)node1;
                SqlTypeCase c2 = (SqlTypeCase)node2;
                if (!AreEqual(c1.Discriminator, c2.Discriminator))
                {
                    return(false);
                }
                if (c1.Whens.Count != c2.Whens.Count)
                {
                    return(false);
                }
                for (int i = 0, c = c1.Whens.Count; i < c; ++i)
                {
                    if (!AreEqual(c1.Whens[i].Match, c2.Whens[i].Match))
                    {
                        return(false);
                    }
                    if (!AreEqual(c1.Whens[i].TypeBinding, c2.Whens[i].TypeBinding))
                    {
                        return(false);
                    }
                }

                return(true);
            }

            case SqlNodeType.SearchedCase: {
                SqlSearchedCase c1 = (SqlSearchedCase)node1;
                SqlSearchedCase c2 = (SqlSearchedCase)node2;
                if (c1.Whens.Count != c2.Whens.Count)
                {
                    return(false);
                }
                for (int i = 0, n = c1.Whens.Count; i < n; i++)
                {
                    if (!AreEqual(c1.Whens[i].Match, c2.Whens[i].Match) ||
                        !AreEqual(c1.Whens[i].Value, c2.Whens[i].Value))
                    {
                        return(false);
                    }
                }
                return(AreEqual(c1.Else, c2.Else));
            }

            case SqlNodeType.ClientCase: {
                SqlClientCase c1 = (SqlClientCase)node1;
                SqlClientCase c2 = (SqlClientCase)node2;
                if (c1.Whens.Count != c2.Whens.Count)
                {
                    return(false);
                }
                for (int i = 0, n = c1.Whens.Count; i < n; i++)
                {
                    if (!AreEqual(c1.Whens[i].Match, c2.Whens[i].Match) ||
                        !AreEqual(c1.Whens[i].Value, c2.Whens[i].Value))
                    {
                        return(false);
                    }
                }
                return(true);
            }

            case SqlNodeType.DiscriminatedType: {
                SqlDiscriminatedType dt1 = (SqlDiscriminatedType)node1;
                SqlDiscriminatedType dt2 = (SqlDiscriminatedType)node2;
                return(AreEqual(dt1.Discriminator, dt2.Discriminator));
            }

            case SqlNodeType.SimpleCase: {
                SqlSimpleCase c1 = (SqlSimpleCase)node1;
                SqlSimpleCase c2 = (SqlSimpleCase)node2;
                if (c1.Whens.Count != c2.Whens.Count)
                {
                    return(false);
                }
                for (int i = 0, n = c1.Whens.Count; i < n; i++)
                {
                    if (!AreEqual(c1.Whens[i].Match, c2.Whens[i].Match) ||
                        !AreEqual(c1.Whens[i].Value, c2.Whens[i].Value))
                    {
                        return(false);
                    }
                }
                return(true);
            }

            case SqlNodeType.Like: {
                SqlLike like1 = (SqlLike)node1;
                SqlLike like2 = (SqlLike)node2;
                return(AreEqual(like1.Expression, like2.Expression) &&
                       AreEqual(like1.Pattern, like2.Pattern) &&
                       AreEqual(like1.Escape, like2.Escape));
            }

            case SqlNodeType.Variable: {
                SqlVariable v1 = (SqlVariable)node1;
                SqlVariable v2 = (SqlVariable)node2;
                return(v1.Name == v2.Name);
            }

            case SqlNodeType.FunctionCall: {
                SqlFunctionCall f1 = (SqlFunctionCall)node1;
                SqlFunctionCall f2 = (SqlFunctionCall)node2;
                if (f1.Name != f2.Name)
                {
                    return(false);
                }
                if (f1.Arguments.Count != f2.Arguments.Count)
                {
                    return(false);
                }
                for (int i = 0, n = f1.Arguments.Count; i < n; i++)
                {
                    if (!AreEqual(f1.Arguments[i], f2.Arguments[i]))
                    {
                        return(false);
                    }
                }
                return(true);
            }

            case SqlNodeType.Link: {
                SqlLink l1 = (SqlLink)node1;
                SqlLink l2 = (SqlLink)node2;
                if (!MetaPosition.AreSameMember(l1.Member.Member, l2.Member.Member))
                {
                    return(false);
                }
                if (!AreEqual(l1.Expansion, l2.Expansion))
                {
                    return(false);
                }
                if (l1.KeyExpressions.Count != l2.KeyExpressions.Count)
                {
                    return(false);
                }
                for (int i = 0, c = l1.KeyExpressions.Count; i < c; ++i)
                {
                    if (!AreEqual(l1.KeyExpressions[i], l2.KeyExpressions[i]))
                    {
                        return(false);
                    }
                }
                return(true);
            }

            case SqlNodeType.ExprSet:
                SqlExprSet es1 = (SqlExprSet)node1;
                SqlExprSet es2 = (SqlExprSet)node2;
                if (es1.Expressions.Count != es2.Expressions.Count)
                {
                    return(false);
                }
                for (int i = 0, n = es1.Expressions.Count; i < n; i++)
                {
                    if (!AreEqual(es1.Expressions[i], es2.Expressions[i]))
                    {
                        return(false);
                    }
                }
                return(true);

            case SqlNodeType.OptionalValue:
                SqlOptionalValue ov1 = (SqlOptionalValue)node1;
                SqlOptionalValue ov2 = (SqlOptionalValue)node2;
                return(AreEqual(ov1.Value, ov2.Value));

            case SqlNodeType.Row:
            case SqlNodeType.UserQuery:
            case SqlNodeType.StoredProcedureCall:
            case SqlNodeType.UserRow:
            case SqlNodeType.UserColumn:
            case SqlNodeType.Multiset:
            case SqlNodeType.ScalarSubSelect:
            case SqlNodeType.Element:
            case SqlNodeType.Exists:
            case SqlNodeType.Join:
            case SqlNodeType.Select:
            case SqlNodeType.New:
            case SqlNodeType.ClientQuery:
            case SqlNodeType.ClientArray:
            case SqlNodeType.Insert:
            case SqlNodeType.Update:
            case SqlNodeType.Delete:
            case SqlNodeType.MemberAssign:
            case SqlNodeType.Assign:
            case SqlNodeType.Block:
            case SqlNodeType.Union:
            case SqlNodeType.DoNotVisit:
            case SqlNodeType.MethodCall:
            case SqlNodeType.Nop:
            default:
                return(false);
            }
        }