SqlVisitor.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DLinq / Dlinq / SqlClient / Common / SqlVisitor.cs / 1305376 / SqlVisitor.cs

                            using System; 
using System.Collections.Generic;
using System.Data.Linq;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis; 

namespace System.Data.Linq.SqlClient { 
    internal abstract class SqlVisitor { 
        int nDepth;
 
        // Visit a SqlNode
        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification="[....]: Cast is dependent on node type and casts do not happen unecessarily in a single code path.")]
        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")] 
        internal virtual SqlNode Visit(SqlNode node) {
            SqlNode result = null; 
            if (node == null) { 
                return null;
            } 

            try {
                nDepth++;
                CheckRecursionDepth(500, nDepth); 

                switch (node.NodeType) { 
                    case SqlNodeType.Not: 
                    case SqlNodeType.Not2V:
                    case SqlNodeType.Negate: 
                    case SqlNodeType.BitNot:
                    case SqlNodeType.IsNull:
                    case SqlNodeType.IsNotNull:
                    case SqlNodeType.Count: 
                    case SqlNodeType.LongCount:
                    case SqlNodeType.Max: 
                    case SqlNodeType.Min: 
                    case SqlNodeType.Sum:
                    case SqlNodeType.Avg: 
                    case SqlNodeType.Stddev:
                    case SqlNodeType.Convert:
                    case SqlNodeType.ValueOf:
                    case SqlNodeType.OuterJoinedValue: 
                    case SqlNodeType.ClrLength:
                        result = this.VisitUnaryOperator((SqlUnary)node); 
                        break; 
                    case SqlNodeType.Lift:
                        result = this.VisitLift((SqlLift)node); 
                        break;
                    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:
                    case SqlNodeType.Coalesce:
                        result = this.VisitBinaryOperator((SqlBinary)node); 
                        break;
                    case SqlNodeType.Between: 
                        result = this.VisitBetween((SqlBetween)node); 
                        break;
                    case SqlNodeType.In: 
                        result = this.VisitIn((SqlIn)node);
                        break;
                    case SqlNodeType.Like:
                        result = this.VisitLike((SqlLike)node); 
                        break;
                    case SqlNodeType.Treat: 
                        result = this.VisitTreat((SqlUnary)node); 
                        break;
                    case SqlNodeType.Alias: 
                        result = this.VisitAlias((SqlAlias)node);
                        break;
                    case SqlNodeType.AliasRef:
                        result = this.VisitAliasRef((SqlAliasRef)node); 
                        break;
                    case SqlNodeType.Member: 
                        result = this.VisitMember((SqlMember)node); 
                        break;
                    case SqlNodeType.Row: 
                        result = this.VisitRow((SqlRow)node);
                        break;
                    case SqlNodeType.Column:
                        result = this.VisitColumn((SqlColumn)node); 
                        break;
                    case SqlNodeType.ColumnRef: 
                        result = this.VisitColumnRef((SqlColumnRef)node); 
                        break;
                    case SqlNodeType.Table: 
                        result = this.VisitTable((SqlTable)node);
                        break;
                    case SqlNodeType.UserQuery:
                        result = this.VisitUserQuery((SqlUserQuery)node); 
                        break;
                    case SqlNodeType.StoredProcedureCall: 
                        result = this.VisitStoredProcedureCall((SqlStoredProcedureCall)node); 
                        break;
                    case SqlNodeType.UserRow: 
                        result = this.VisitUserRow((SqlUserRow)node);
                        break;
                    case SqlNodeType.UserColumn:
                        result = this.VisitUserColumn((SqlUserColumn)node); 
                        break;
                    case SqlNodeType.Multiset: 
                    case SqlNodeType.ScalarSubSelect: 
                    case SqlNodeType.Element:
                    case SqlNodeType.Exists: 
                        result = this.VisitSubSelect((SqlSubSelect)node);
                        break;
                    case SqlNodeType.Join:
                        result = this.VisitJoin((SqlJoin)node); 
                        break;
                    case SqlNodeType.Select: 
                        result = this.VisitSelect((SqlSelect)node); 
                        break;
                    case SqlNodeType.Parameter: 
                        result = this.VisitParameter((SqlParameter)node);
                        break;
                    case SqlNodeType.New:
                        result = this.VisitNew((SqlNew)node); 
                        break;
                    case SqlNodeType.Link: 
                        result = this.VisitLink((SqlLink)node); 
                        break;
                    case SqlNodeType.ClientQuery: 
                        result = this.VisitClientQuery((SqlClientQuery)node);
                        break;
                    case SqlNodeType.JoinedCollection:
                        result = this.VisitJoinedCollection((SqlJoinedCollection)node); 
                        break;
                    case SqlNodeType.Value: 
                        result = this.VisitValue((SqlValue)node); 
                        break;
                    case SqlNodeType.ClientArray: 
                        result = this.VisitClientArray((SqlClientArray)node);
                        break;
                    case SqlNodeType.Insert:
                        result = this.VisitInsert((SqlInsert)node); 
                        break;
                    case SqlNodeType.Update: 
                        result = this.VisitUpdate((SqlUpdate)node); 
                        break;
                    case SqlNodeType.Delete: 
                        result = this.VisitDelete((SqlDelete)node);
                        break;
                    case SqlNodeType.MemberAssign:
                        result = this.VisitMemberAssign((SqlMemberAssign)node); 
                        break;
                    case SqlNodeType.Assign: 
                        result = this.VisitAssign((SqlAssign)node); 
                        break;
                    case SqlNodeType.Block: 
                        result = this.VisitBlock((SqlBlock)node);
                        break;
                    case SqlNodeType.SearchedCase:
                        result = this.VisitSearchedCase((SqlSearchedCase)node); 
                        break;
                    case SqlNodeType.ClientCase: 
                        result = this.VisitClientCase((SqlClientCase)node); 
                        break;
                    case SqlNodeType.SimpleCase: 
                        result = this.VisitSimpleCase((SqlSimpleCase)node);
                        break;
                    case SqlNodeType.TypeCase:
                        result = this.VisitTypeCase((SqlTypeCase)node); 
                        break;
                    case SqlNodeType.Union: 
                        result = this.VisitUnion((SqlUnion)node); 
                        break;
                    case SqlNodeType.ExprSet: 
                        result = this.VisitExprSet((SqlExprSet)node);
                        break;
                    case SqlNodeType.Variable:
                        result = this.VisitVariable((SqlVariable)node); 
                        break;
                    case SqlNodeType.DoNotVisit: 
                        result = this.VisitDoNotVisit((SqlDoNotVisitExpression)node); 
                        break;
                    case SqlNodeType.OptionalValue: 
                        result = this.VisitOptionalValue((SqlOptionalValue)node);
                        break;
                    case SqlNodeType.FunctionCall:
                        result = this.VisitFunctionCall((SqlFunctionCall)node); 
                        break;
                    case SqlNodeType.TableValuedFunctionCall: 
                        result = this.VisitTableValuedFunctionCall((SqlTableValuedFunctionCall)node); 
                        break;
                    case SqlNodeType.MethodCall: 
                        result = this.VisitMethodCall((SqlMethodCall)node);
                        break;
                    case SqlNodeType.Nop:
                        result = this.VisitNop((SqlNop)node); 
                        break;
                    case SqlNodeType.SharedExpression: 
                        result = this.VisitSharedExpression((SqlSharedExpression)node); 
                        break;
                    case SqlNodeType.SharedExpressionRef: 
                        result = this.VisitSharedExpressionRef((SqlSharedExpressionRef)node);
                        break;
                    case SqlNodeType.SimpleExpression:
                        result = this.VisitSimpleExpression((SqlSimpleExpression)node); 
                        break;
                    case SqlNodeType.Grouping: 
                        result = this.VisitGrouping((SqlGrouping)node); 
                        break;
                    case SqlNodeType.DiscriminatedType: 
                        result = this.VisitDiscriminatedType((SqlDiscriminatedType)node);
                        break;
                    case SqlNodeType.DiscriminatorOf:
                        result = this.VisitDiscriminatorOf((SqlDiscriminatorOf)node); 
                        break;
                    case SqlNodeType.ClientParameter: 
                        result = this.VisitClientParameter((SqlClientParameter)node); 
                        break;
                    case SqlNodeType.RowNumber: 
                        result = this.VisitRowNumber((SqlRowNumber)node);
                        break;
                    case SqlNodeType.IncludeScope:
                        result = this.VisitIncludeScope((SqlIncludeScope)node); 
                        break;
                    default: 
                        throw Error.UnexpectedNode(node); 
                }
            } finally { 
                this.nDepth--;
            }

            return result; 
        }
 
 
        /// 
        /// This method checks the recursion level to help diagnose/prevent 
        /// infinite recursion in debug builds. Calls are ommitted in non debug builds.
        /// 
        [SuppressMessage("Microsoft.Usage", "CA2201:DoNotRaiseReservedExceptionTypes", Justification="Debug-only code.")]
        [Conditional("DEBUG")] 
        internal static void CheckRecursionDepth(int maxLevel, int level) {
            if (level > maxLevel) { 
                System.Diagnostics.Debug.Assert(false); 
                //**********************************************************************
                // EXCLUDING FROM LOCALIZATION. 
                // Reason: This code only executes in DEBUG.
                throw new Exception("Infinite Descent?");
                //*********************************************************************
            } 
        }
 
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")] 
        internal object Eval(SqlExpression expr) {
            if (expr.NodeType == SqlNodeType.Value) { 
                return ((SqlValue)expr).Value;
            }
            throw Error.UnexpectedNode(expr.NodeType);
        } 

        internal virtual SqlExpression VisitDoNotVisit(SqlDoNotVisitExpression expr) { 
            return expr.Expression; 
        }
        internal virtual SqlRowNumber VisitRowNumber(SqlRowNumber rowNumber) { 
            for (int i = 0, n = rowNumber.OrderBy.Count; i < n; i++) {
                rowNumber.OrderBy[i].Expression = this.VisitExpression(rowNumber.OrderBy[i].Expression);
            }
 
            return rowNumber;
        } 
        internal virtual SqlExpression VisitExpression(SqlExpression exp) { 
            return (SqlExpression)this.Visit(exp);
        } 
        internal virtual SqlSelect VisitSequence(SqlSelect sel) {
            return (SqlSelect)this.Visit(sel);
        }
        internal virtual SqlExpression VisitNop(SqlNop nop) { 
            return nop;
        } 
        internal virtual SqlExpression VisitLift(SqlLift lift) { 
            lift.Expression = this.VisitExpression(lift.Expression);
            return lift; 
        }
        internal virtual SqlExpression VisitUnaryOperator(SqlUnary uo) {
            uo.Operand = this.VisitExpression(uo.Operand);
            return uo; 
        }
        internal virtual SqlExpression VisitBinaryOperator(SqlBinary bo) { 
            bo.Left = this.VisitExpression(bo.Left); 
            bo.Right = this.VisitExpression(bo.Right);
            return bo; 
        }
        internal virtual SqlAlias VisitAlias(SqlAlias a) {
            a.Node = this.Visit(a.Node);
            return a; 
        }
        internal virtual SqlExpression VisitAliasRef(SqlAliasRef aref) { 
            return aref; 
        }
        internal virtual SqlNode VisitMember(SqlMember m) { 
            m.Expression = this.VisitExpression(m.Expression);
            return m;
        }
        internal virtual SqlExpression VisitCast(SqlUnary c) { 
            c.Operand = this.VisitExpression(c.Operand);
            return c; 
        } 
        internal virtual SqlExpression VisitTreat(SqlUnary t) {
            t.Operand = this.VisitExpression(t.Operand); 
            return t;
        }
        internal virtual SqlTable VisitTable(SqlTable tab) {
            return tab; 
        }
        internal virtual SqlUserQuery VisitUserQuery(SqlUserQuery suq) { 
            for (int i = 0, n = suq.Arguments.Count; i < n; i++) { 
                suq.Arguments[i] = this.VisitExpression(suq.Arguments[i]);
            } 
            suq.Projection = this.VisitExpression(suq.Projection);
            for (int i = 0, n = suq.Columns.Count; i < n; i++) {
                suq.Columns[i] = (SqlUserColumn) this.Visit(suq.Columns[i]);
            } 
            return suq;
        } 
        internal virtual SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { 
            for (int i = 0, n = spc.Arguments.Count; i < n; i++) {
                spc.Arguments[i] = this.VisitExpression(spc.Arguments[i]); 
            }
            spc.Projection = this.VisitExpression(spc.Projection);
            for (int i = 0, n = spc.Columns.Count; i < n; i++) {
                spc.Columns[i] = (SqlUserColumn) this.Visit(spc.Columns[i]); 
            }
            return spc; 
        } 
        internal virtual SqlExpression VisitUserColumn(SqlUserColumn suc) {
            return suc; 
        }
        internal virtual SqlExpression VisitUserRow(SqlUserRow row) {
            return row;
        } 
        internal virtual SqlRow VisitRow(SqlRow row) {
            for (int i = 0, n = row.Columns.Count; i < n; i++) { 
                row.Columns[i].Expression = this.VisitExpression(row.Columns[i].Expression); 
            }
            return row; 
        }
        internal virtual SqlExpression VisitNew(SqlNew sox) {
            for (int i = 0, n = sox.Args.Count; i < n; i++) {
                sox.Args[i] = this.VisitExpression(sox.Args[i]); 
            }
            for (int i = 0, n = sox.Members.Count; i < n; i++) { 
                sox.Members[i].Expression = this.VisitExpression(sox.Members[i].Expression); 
            }
            return sox; 
        }
        internal virtual SqlNode VisitLink(SqlLink link) {
            // Don't visit the link's Expansion
            for (int i = 0, n = link.KeyExpressions.Count; i < n; i++) { 
                link.KeyExpressions[i] = this.VisitExpression(link.KeyExpressions[i]);
            } 
            return link; 
        }
        internal virtual SqlExpression VisitClientQuery(SqlClientQuery cq) { 
            for (int i = 0, n = cq.Arguments.Count; i < n; i++) {
                cq.Arguments[i] = this.VisitExpression(cq.Arguments[i]);
            }
            return cq; 
        }
        internal virtual SqlExpression VisitJoinedCollection(SqlJoinedCollection jc) { 
            jc.Expression = this.VisitExpression(jc.Expression); 
            jc.Count = this.VisitExpression(jc.Count);
            return jc; 
        }
        internal virtual SqlExpression VisitClientArray(SqlClientArray scar) {
            for (int i = 0, n = scar.Expressions.Count; i < n; i++) {
                scar.Expressions[i] = this.VisitExpression(scar.Expressions[i]); 
            }
            return scar; 
        } 
        internal virtual SqlExpression VisitClientParameter(SqlClientParameter cp) {
            return cp; 
        }
        internal virtual SqlExpression VisitColumn(SqlColumn col) {
            col.Expression = this.VisitExpression(col.Expression);
            return col; 
        }
        internal virtual SqlExpression VisitColumnRef(SqlColumnRef cref) { 
            return cref; 
        }
        internal virtual SqlExpression VisitParameter(SqlParameter p) { 
            return p;
        }
        internal virtual SqlExpression VisitValue(SqlValue value) {
            return value; 
        }
        internal virtual SqlExpression VisitSubSelect(SqlSubSelect ss) { 
            switch(ss.NodeType) { 
               case SqlNodeType.ScalarSubSelect: return this.VisitScalarSubSelect(ss);
               case SqlNodeType.Multiset: return this.VisitMultiset(ss); 
               case SqlNodeType.Element: return this.VisitElement(ss);
               case SqlNodeType.Exists: return this.VisitExists(ss);
            }
            throw Error.UnexpectedNode(ss.NodeType); 
        }
        internal virtual SqlExpression VisitScalarSubSelect(SqlSubSelect ss) { 
            ss.Select = this.VisitSequence(ss.Select); 
            return ss;
        } 
        internal virtual SqlExpression VisitMultiset(SqlSubSelect sms) {
            sms.Select = this.VisitSequence(sms.Select);
            return sms;
        } 
        internal virtual SqlExpression VisitElement(SqlSubSelect elem) {
            elem.Select = this.VisitSequence(elem.Select); 
            return elem; 
        }
        internal virtual SqlExpression VisitExists(SqlSubSelect sqlExpr) { 
            sqlExpr.Select = this.VisitSequence(sqlExpr.Select);
            return sqlExpr;
        }
        internal virtual SqlSource VisitJoin(SqlJoin join) { 
            join.Left = this.VisitSource(join.Left);
            join.Right = this.VisitSource(join.Right); 
            join.Condition = this.VisitExpression(join.Condition); 
            return join;
        } 
        internal virtual SqlSource VisitSource(SqlSource source) {
            return (SqlSource) this.Visit(source);
        }
        internal virtual SqlSelect VisitSelectCore(SqlSelect select) { 
            select.From = this.VisitSource(select.From);
            select.Where = this.VisitExpression(select.Where); 
            for (int i = 0, n = select.GroupBy.Count; i < n; i++) { 
                select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
            } 
            select.Having = this.VisitExpression(select.Having);
            for (int i = 0, n = select.OrderBy.Count; i < n; i++) {
                select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
            } 
            select.Top = this.VisitExpression(select.Top);
            select.Row = (SqlRow)this.Visit(select.Row); 
            return select; 
        }
        internal virtual SqlSelect VisitSelect(SqlSelect select) { 
            select = this.VisitSelectCore(select);
            select.Selection = this.VisitExpression(select.Selection);
            return select;
        } 
        internal virtual SqlStatement VisitInsert(SqlInsert insert) {
            insert.Table = (SqlTable)this.Visit(insert.Table); 
            insert.Expression = this.VisitExpression(insert.Expression); 
            insert.Row = (SqlRow)this.Visit(insert.Row);
            return insert; 
        }
        internal virtual SqlStatement VisitUpdate(SqlUpdate update) {
            update.Select = this.VisitSequence(update.Select);
            for (int i = 0, n = update.Assignments.Count; i < n; i++) { 
                update.Assignments[i] = (SqlAssign)this.Visit(update.Assignments[i]);
            } 
            return update; 
        }
        internal virtual SqlStatement VisitDelete(SqlDelete delete) { 
            delete.Select = this.VisitSequence(delete.Select);
            return delete;
        }
        internal virtual SqlMemberAssign VisitMemberAssign(SqlMemberAssign ma) { 
            ma.Expression = this.VisitExpression(ma.Expression);
            return ma; 
        } 
        internal virtual SqlStatement VisitAssign(SqlAssign sa) {
            sa.LValue = this.VisitExpression(sa.LValue); 
            sa.RValue = this.VisitExpression(sa.RValue);
            return sa;
        }
        internal virtual SqlBlock VisitBlock(SqlBlock b) { 
            for (int i = 0, n = b.Statements.Count; i < n; i++) {
                b.Statements[i] = (SqlStatement)this.Visit(b.Statements[i]); 
            } 
            return b;
        } 
        internal virtual SqlExpression VisitSearchedCase(SqlSearchedCase c) {
            for (int i = 0, n = c.Whens.Count; i < n; i++) {
                SqlWhen when = c.Whens[i];
                when.Match = this.VisitExpression(when.Match); 
                when.Value = this.VisitExpression(when.Value);
            } 
            c.Else = this.VisitExpression(c.Else); 
            return c;
        } 
        internal virtual SqlExpression VisitClientCase(SqlClientCase c) {
            c.Expression = this.VisitExpression(c.Expression);
            for (int i = 0, n = c.Whens.Count; i < n; i++) {
                SqlClientWhen when = c.Whens[i]; 
                when.Match = this.VisitExpression(when.Match);
                when.Value = this.VisitExpression(when.Value); 
            } 
            return c;
        } 
        internal virtual SqlExpression VisitSimpleCase(SqlSimpleCase c) {
            c.Expression = this.VisitExpression(c.Expression);
            for (int i = 0, n = c.Whens.Count; i < n; i++) {
                SqlWhen when = c.Whens[i]; 
                when.Match = this.VisitExpression(when.Match);
                when.Value = this.VisitExpression(when.Value); 
            } 
            return c;
        } 
        internal virtual SqlExpression VisitTypeCase(SqlTypeCase tc) {
            tc.Discriminator = this.VisitExpression(tc.Discriminator);
            for (int i = 0, n = tc.Whens.Count; i < n; i++) {
                SqlTypeCaseWhen when = tc.Whens[i]; 
                when.Match = this.VisitExpression(when.Match);
                when.TypeBinding = this.VisitExpression(when.TypeBinding); 
            } 
            return tc;
        } 
        internal virtual SqlNode VisitUnion(SqlUnion su) {
            su.Left = this.Visit(su.Left);
            su.Right = this.Visit(su.Right);
            return su; 
        }
        internal virtual SqlExpression VisitExprSet(SqlExprSet xs) { 
            for (int i = 0, n = xs.Expressions.Count; i < n; i++) { 
                xs.Expressions[i] = this.VisitExpression(xs.Expressions[i]);
            } 
            return xs;
        }
        internal virtual SqlExpression VisitVariable(SqlVariable v) {
            return v; 
        }
        internal virtual SqlExpression VisitOptionalValue(SqlOptionalValue sov) { 
            sov.HasValue = this.VisitExpression(sov.HasValue); 
            sov.Value = this.VisitExpression(sov.Value);
            return sov; 
        }
        internal virtual SqlExpression VisitBetween(SqlBetween between) {
            between.Expression = this.VisitExpression(between.Expression);
            between.Start = this.VisitExpression(between.Start); 
            between.End = this.VisitExpression(between.End);
            return between; 
        } 
        internal virtual SqlExpression VisitIn(SqlIn sin) {
            sin.Expression = this.VisitExpression(sin.Expression); 
            for (int i = 0, n = sin.Values.Count; i < n; i++) {
                sin.Values[i] = this.VisitExpression(sin.Values[i]);
            }
            return sin; 
        }
        internal virtual SqlExpression VisitLike(SqlLike like) { 
            like.Expression = this.VisitExpression(like.Expression); 
            like.Pattern = this.VisitExpression(like.Pattern);
            like.Escape = this.VisitExpression(like.Escape); 
            return like;
        }
        internal virtual SqlExpression VisitFunctionCall(SqlFunctionCall fc) {
            for (int i = 0, n = fc.Arguments.Count; i < n; i++) { 
                fc.Arguments[i] = this.VisitExpression(fc.Arguments[i]);
            } 
            return fc; 
        }
        internal virtual SqlExpression VisitTableValuedFunctionCall(SqlTableValuedFunctionCall fc) { 
            for (int i = 0, n = fc.Arguments.Count; i < n; i++) {
                fc.Arguments[i] = this.VisitExpression(fc.Arguments[i]);
            }
            return fc; 
        }
        internal virtual SqlExpression VisitMethodCall(SqlMethodCall mc) { 
            mc.Object = this.VisitExpression(mc.Object); 
            for (int i = 0, n = mc.Arguments.Count; i < n; i++) {
                mc.Arguments[i] = this.VisitExpression(mc.Arguments[i]); 
            }
            return mc;
        }
        internal virtual SqlExpression VisitSharedExpression(SqlSharedExpression shared) { 
            shared.Expression = this.VisitExpression(shared.Expression);
            return shared; 
        } 
        internal virtual SqlExpression VisitSharedExpressionRef(SqlSharedExpressionRef sref) {
            return sref; 
        }
        internal virtual SqlExpression VisitSimpleExpression(SqlSimpleExpression simple) {
            simple.Expression = this.VisitExpression(simple.Expression);
            return simple; 
        }
        internal virtual SqlExpression VisitGrouping(SqlGrouping g) { 
            g.Key = this.VisitExpression(g.Key); 
            g.Group = this.VisitExpression(g.Group);
            return g; 
        }
        internal virtual SqlExpression VisitDiscriminatedType(SqlDiscriminatedType dt) {
            dt.Discriminator = this.VisitExpression(dt.Discriminator);
            return dt; 
        }
        internal virtual SqlExpression VisitDiscriminatorOf(SqlDiscriminatorOf dof) { 
            dof.Object = this.VisitExpression(dof.Object); 
            return dof;
        } 
        internal virtual SqlNode VisitIncludeScope(SqlIncludeScope node) {
            node.Child = this.Visit(node.Child);
            return node;
        } 

#if DEBUG 
        int refersDepth; 
#endif
        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
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System; 
using System.Collections.Generic;
using System.Data.Linq;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis; 

namespace System.Data.Linq.SqlClient { 
    internal abstract class SqlVisitor { 
        int nDepth;
 
        // Visit a SqlNode
        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification="[....]: Cast is dependent on node type and casts do not happen unecessarily in a single code path.")]
        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")] 
        internal virtual SqlNode Visit(SqlNode node) {
            SqlNode result = null; 
            if (node == null) { 
                return null;
            } 

            try {
                nDepth++;
                CheckRecursionDepth(500, nDepth); 

                switch (node.NodeType) { 
                    case SqlNodeType.Not: 
                    case SqlNodeType.Not2V:
                    case SqlNodeType.Negate: 
                    case SqlNodeType.BitNot:
                    case SqlNodeType.IsNull:
                    case SqlNodeType.IsNotNull:
                    case SqlNodeType.Count: 
                    case SqlNodeType.LongCount:
                    case SqlNodeType.Max: 
                    case SqlNodeType.Min: 
                    case SqlNodeType.Sum:
                    case SqlNodeType.Avg: 
                    case SqlNodeType.Stddev:
                    case SqlNodeType.Convert:
                    case SqlNodeType.ValueOf:
                    case SqlNodeType.OuterJoinedValue: 
                    case SqlNodeType.ClrLength:
                        result = this.VisitUnaryOperator((SqlUnary)node); 
                        break; 
                    case SqlNodeType.Lift:
                        result = this.VisitLift((SqlLift)node); 
                        break;
                    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:
                    case SqlNodeType.Coalesce:
                        result = this.VisitBinaryOperator((SqlBinary)node); 
                        break;
                    case SqlNodeType.Between: 
                        result = this.VisitBetween((SqlBetween)node); 
                        break;
                    case SqlNodeType.In: 
                        result = this.VisitIn((SqlIn)node);
                        break;
                    case SqlNodeType.Like:
                        result = this.VisitLike((SqlLike)node); 
                        break;
                    case SqlNodeType.Treat: 
                        result = this.VisitTreat((SqlUnary)node); 
                        break;
                    case SqlNodeType.Alias: 
                        result = this.VisitAlias((SqlAlias)node);
                        break;
                    case SqlNodeType.AliasRef:
                        result = this.VisitAliasRef((SqlAliasRef)node); 
                        break;
                    case SqlNodeType.Member: 
                        result = this.VisitMember((SqlMember)node); 
                        break;
                    case SqlNodeType.Row: 
                        result = this.VisitRow((SqlRow)node);
                        break;
                    case SqlNodeType.Column:
                        result = this.VisitColumn((SqlColumn)node); 
                        break;
                    case SqlNodeType.ColumnRef: 
                        result = this.VisitColumnRef((SqlColumnRef)node); 
                        break;
                    case SqlNodeType.Table: 
                        result = this.VisitTable((SqlTable)node);
                        break;
                    case SqlNodeType.UserQuery:
                        result = this.VisitUserQuery((SqlUserQuery)node); 
                        break;
                    case SqlNodeType.StoredProcedureCall: 
                        result = this.VisitStoredProcedureCall((SqlStoredProcedureCall)node); 
                        break;
                    case SqlNodeType.UserRow: 
                        result = this.VisitUserRow((SqlUserRow)node);
                        break;
                    case SqlNodeType.UserColumn:
                        result = this.VisitUserColumn((SqlUserColumn)node); 
                        break;
                    case SqlNodeType.Multiset: 
                    case SqlNodeType.ScalarSubSelect: 
                    case SqlNodeType.Element:
                    case SqlNodeType.Exists: 
                        result = this.VisitSubSelect((SqlSubSelect)node);
                        break;
                    case SqlNodeType.Join:
                        result = this.VisitJoin((SqlJoin)node); 
                        break;
                    case SqlNodeType.Select: 
                        result = this.VisitSelect((SqlSelect)node); 
                        break;
                    case SqlNodeType.Parameter: 
                        result = this.VisitParameter((SqlParameter)node);
                        break;
                    case SqlNodeType.New:
                        result = this.VisitNew((SqlNew)node); 
                        break;
                    case SqlNodeType.Link: 
                        result = this.VisitLink((SqlLink)node); 
                        break;
                    case SqlNodeType.ClientQuery: 
                        result = this.VisitClientQuery((SqlClientQuery)node);
                        break;
                    case SqlNodeType.JoinedCollection:
                        result = this.VisitJoinedCollection((SqlJoinedCollection)node); 
                        break;
                    case SqlNodeType.Value: 
                        result = this.VisitValue((SqlValue)node); 
                        break;
                    case SqlNodeType.ClientArray: 
                        result = this.VisitClientArray((SqlClientArray)node);
                        break;
                    case SqlNodeType.Insert:
                        result = this.VisitInsert((SqlInsert)node); 
                        break;
                    case SqlNodeType.Update: 
                        result = this.VisitUpdate((SqlUpdate)node); 
                        break;
                    case SqlNodeType.Delete: 
                        result = this.VisitDelete((SqlDelete)node);
                        break;
                    case SqlNodeType.MemberAssign:
                        result = this.VisitMemberAssign((SqlMemberAssign)node); 
                        break;
                    case SqlNodeType.Assign: 
                        result = this.VisitAssign((SqlAssign)node); 
                        break;
                    case SqlNodeType.Block: 
                        result = this.VisitBlock((SqlBlock)node);
                        break;
                    case SqlNodeType.SearchedCase:
                        result = this.VisitSearchedCase((SqlSearchedCase)node); 
                        break;
                    case SqlNodeType.ClientCase: 
                        result = this.VisitClientCase((SqlClientCase)node); 
                        break;
                    case SqlNodeType.SimpleCase: 
                        result = this.VisitSimpleCase((SqlSimpleCase)node);
                        break;
                    case SqlNodeType.TypeCase:
                        result = this.VisitTypeCase((SqlTypeCase)node); 
                        break;
                    case SqlNodeType.Union: 
                        result = this.VisitUnion((SqlUnion)node); 
                        break;
                    case SqlNodeType.ExprSet: 
                        result = this.VisitExprSet((SqlExprSet)node);
                        break;
                    case SqlNodeType.Variable:
                        result = this.VisitVariable((SqlVariable)node); 
                        break;
                    case SqlNodeType.DoNotVisit: 
                        result = this.VisitDoNotVisit((SqlDoNotVisitExpression)node); 
                        break;
                    case SqlNodeType.OptionalValue: 
                        result = this.VisitOptionalValue((SqlOptionalValue)node);
                        break;
                    case SqlNodeType.FunctionCall:
                        result = this.VisitFunctionCall((SqlFunctionCall)node); 
                        break;
                    case SqlNodeType.TableValuedFunctionCall: 
                        result = this.VisitTableValuedFunctionCall((SqlTableValuedFunctionCall)node); 
                        break;
                    case SqlNodeType.MethodCall: 
                        result = this.VisitMethodCall((SqlMethodCall)node);
                        break;
                    case SqlNodeType.Nop:
                        result = this.VisitNop((SqlNop)node); 
                        break;
                    case SqlNodeType.SharedExpression: 
                        result = this.VisitSharedExpression((SqlSharedExpression)node); 
                        break;
                    case SqlNodeType.SharedExpressionRef: 
                        result = this.VisitSharedExpressionRef((SqlSharedExpressionRef)node);
                        break;
                    case SqlNodeType.SimpleExpression:
                        result = this.VisitSimpleExpression((SqlSimpleExpression)node); 
                        break;
                    case SqlNodeType.Grouping: 
                        result = this.VisitGrouping((SqlGrouping)node); 
                        break;
                    case SqlNodeType.DiscriminatedType: 
                        result = this.VisitDiscriminatedType((SqlDiscriminatedType)node);
                        break;
                    case SqlNodeType.DiscriminatorOf:
                        result = this.VisitDiscriminatorOf((SqlDiscriminatorOf)node); 
                        break;
                    case SqlNodeType.ClientParameter: 
                        result = this.VisitClientParameter((SqlClientParameter)node); 
                        break;
                    case SqlNodeType.RowNumber: 
                        result = this.VisitRowNumber((SqlRowNumber)node);
                        break;
                    case SqlNodeType.IncludeScope:
                        result = this.VisitIncludeScope((SqlIncludeScope)node); 
                        break;
                    default: 
                        throw Error.UnexpectedNode(node); 
                }
            } finally { 
                this.nDepth--;
            }

            return result; 
        }
 
 
        /// 
        /// This method checks the recursion level to help diagnose/prevent 
        /// infinite recursion in debug builds. Calls are ommitted in non debug builds.
        /// 
        [SuppressMessage("Microsoft.Usage", "CA2201:DoNotRaiseReservedExceptionTypes", Justification="Debug-only code.")]
        [Conditional("DEBUG")] 
        internal static void CheckRecursionDepth(int maxLevel, int level) {
            if (level > maxLevel) { 
                System.Diagnostics.Debug.Assert(false); 
                //**********************************************************************
                // EXCLUDING FROM LOCALIZATION. 
                // Reason: This code only executes in DEBUG.
                throw new Exception("Infinite Descent?");
                //*********************************************************************
            } 
        }
 
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")] 
        internal object Eval(SqlExpression expr) {
            if (expr.NodeType == SqlNodeType.Value) { 
                return ((SqlValue)expr).Value;
            }
            throw Error.UnexpectedNode(expr.NodeType);
        } 

        internal virtual SqlExpression VisitDoNotVisit(SqlDoNotVisitExpression expr) { 
            return expr.Expression; 
        }
        internal virtual SqlRowNumber VisitRowNumber(SqlRowNumber rowNumber) { 
            for (int i = 0, n = rowNumber.OrderBy.Count; i < n; i++) {
                rowNumber.OrderBy[i].Expression = this.VisitExpression(rowNumber.OrderBy[i].Expression);
            }
 
            return rowNumber;
        } 
        internal virtual SqlExpression VisitExpression(SqlExpression exp) { 
            return (SqlExpression)this.Visit(exp);
        } 
        internal virtual SqlSelect VisitSequence(SqlSelect sel) {
            return (SqlSelect)this.Visit(sel);
        }
        internal virtual SqlExpression VisitNop(SqlNop nop) { 
            return nop;
        } 
        internal virtual SqlExpression VisitLift(SqlLift lift) { 
            lift.Expression = this.VisitExpression(lift.Expression);
            return lift; 
        }
        internal virtual SqlExpression VisitUnaryOperator(SqlUnary uo) {
            uo.Operand = this.VisitExpression(uo.Operand);
            return uo; 
        }
        internal virtual SqlExpression VisitBinaryOperator(SqlBinary bo) { 
            bo.Left = this.VisitExpression(bo.Left); 
            bo.Right = this.VisitExpression(bo.Right);
            return bo; 
        }
        internal virtual SqlAlias VisitAlias(SqlAlias a) {
            a.Node = this.Visit(a.Node);
            return a; 
        }
        internal virtual SqlExpression VisitAliasRef(SqlAliasRef aref) { 
            return aref; 
        }
        internal virtual SqlNode VisitMember(SqlMember m) { 
            m.Expression = this.VisitExpression(m.Expression);
            return m;
        }
        internal virtual SqlExpression VisitCast(SqlUnary c) { 
            c.Operand = this.VisitExpression(c.Operand);
            return c; 
        } 
        internal virtual SqlExpression VisitTreat(SqlUnary t) {
            t.Operand = this.VisitExpression(t.Operand); 
            return t;
        }
        internal virtual SqlTable VisitTable(SqlTable tab) {
            return tab; 
        }
        internal virtual SqlUserQuery VisitUserQuery(SqlUserQuery suq) { 
            for (int i = 0, n = suq.Arguments.Count; i < n; i++) { 
                suq.Arguments[i] = this.VisitExpression(suq.Arguments[i]);
            } 
            suq.Projection = this.VisitExpression(suq.Projection);
            for (int i = 0, n = suq.Columns.Count; i < n; i++) {
                suq.Columns[i] = (SqlUserColumn) this.Visit(suq.Columns[i]);
            } 
            return suq;
        } 
        internal virtual SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) { 
            for (int i = 0, n = spc.Arguments.Count; i < n; i++) {
                spc.Arguments[i] = this.VisitExpression(spc.Arguments[i]); 
            }
            spc.Projection = this.VisitExpression(spc.Projection);
            for (int i = 0, n = spc.Columns.Count; i < n; i++) {
                spc.Columns[i] = (SqlUserColumn) this.Visit(spc.Columns[i]); 
            }
            return spc; 
        } 
        internal virtual SqlExpression VisitUserColumn(SqlUserColumn suc) {
            return suc; 
        }
        internal virtual SqlExpression VisitUserRow(SqlUserRow row) {
            return row;
        } 
        internal virtual SqlRow VisitRow(SqlRow row) {
            for (int i = 0, n = row.Columns.Count; i < n; i++) { 
                row.Columns[i].Expression = this.VisitExpression(row.Columns[i].Expression); 
            }
            return row; 
        }
        internal virtual SqlExpression VisitNew(SqlNew sox) {
            for (int i = 0, n = sox.Args.Count; i < n; i++) {
                sox.Args[i] = this.VisitExpression(sox.Args[i]); 
            }
            for (int i = 0, n = sox.Members.Count; i < n; i++) { 
                sox.Members[i].Expression = this.VisitExpression(sox.Members[i].Expression); 
            }
            return sox; 
        }
        internal virtual SqlNode VisitLink(SqlLink link) {
            // Don't visit the link's Expansion
            for (int i = 0, n = link.KeyExpressions.Count; i < n; i++) { 
                link.KeyExpressions[i] = this.VisitExpression(link.KeyExpressions[i]);
            } 
            return link; 
        }
        internal virtual SqlExpression VisitClientQuery(SqlClientQuery cq) { 
            for (int i = 0, n = cq.Arguments.Count; i < n; i++) {
                cq.Arguments[i] = this.VisitExpression(cq.Arguments[i]);
            }
            return cq; 
        }
        internal virtual SqlExpression VisitJoinedCollection(SqlJoinedCollection jc) { 
            jc.Expression = this.VisitExpression(jc.Expression); 
            jc.Count = this.VisitExpression(jc.Count);
            return jc; 
        }
        internal virtual SqlExpression VisitClientArray(SqlClientArray scar) {
            for (int i = 0, n = scar.Expressions.Count; i < n; i++) {
                scar.Expressions[i] = this.VisitExpression(scar.Expressions[i]); 
            }
            return scar; 
        } 
        internal virtual SqlExpression VisitClientParameter(SqlClientParameter cp) {
            return cp; 
        }
        internal virtual SqlExpression VisitColumn(SqlColumn col) {
            col.Expression = this.VisitExpression(col.Expression);
            return col; 
        }
        internal virtual SqlExpression VisitColumnRef(SqlColumnRef cref) { 
            return cref; 
        }
        internal virtual SqlExpression VisitParameter(SqlParameter p) { 
            return p;
        }
        internal virtual SqlExpression VisitValue(SqlValue value) {
            return value; 
        }
        internal virtual SqlExpression VisitSubSelect(SqlSubSelect ss) { 
            switch(ss.NodeType) { 
               case SqlNodeType.ScalarSubSelect: return this.VisitScalarSubSelect(ss);
               case SqlNodeType.Multiset: return this.VisitMultiset(ss); 
               case SqlNodeType.Element: return this.VisitElement(ss);
               case SqlNodeType.Exists: return this.VisitExists(ss);
            }
            throw Error.UnexpectedNode(ss.NodeType); 
        }
        internal virtual SqlExpression VisitScalarSubSelect(SqlSubSelect ss) { 
            ss.Select = this.VisitSequence(ss.Select); 
            return ss;
        } 
        internal virtual SqlExpression VisitMultiset(SqlSubSelect sms) {
            sms.Select = this.VisitSequence(sms.Select);
            return sms;
        } 
        internal virtual SqlExpression VisitElement(SqlSubSelect elem) {
            elem.Select = this.VisitSequence(elem.Select); 
            return elem; 
        }
        internal virtual SqlExpression VisitExists(SqlSubSelect sqlExpr) { 
            sqlExpr.Select = this.VisitSequence(sqlExpr.Select);
            return sqlExpr;
        }
        internal virtual SqlSource VisitJoin(SqlJoin join) { 
            join.Left = this.VisitSource(join.Left);
            join.Right = this.VisitSource(join.Right); 
            join.Condition = this.VisitExpression(join.Condition); 
            return join;
        } 
        internal virtual SqlSource VisitSource(SqlSource source) {
            return (SqlSource) this.Visit(source);
        }
        internal virtual SqlSelect VisitSelectCore(SqlSelect select) { 
            select.From = this.VisitSource(select.From);
            select.Where = this.VisitExpression(select.Where); 
            for (int i = 0, n = select.GroupBy.Count; i < n; i++) { 
                select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
            } 
            select.Having = this.VisitExpression(select.Having);
            for (int i = 0, n = select.OrderBy.Count; i < n; i++) {
                select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
            } 
            select.Top = this.VisitExpression(select.Top);
            select.Row = (SqlRow)this.Visit(select.Row); 
            return select; 
        }
        internal virtual SqlSelect VisitSelect(SqlSelect select) { 
            select = this.VisitSelectCore(select);
            select.Selection = this.VisitExpression(select.Selection);
            return select;
        } 
        internal virtual SqlStatement VisitInsert(SqlInsert insert) {
            insert.Table = (SqlTable)this.Visit(insert.Table); 
            insert.Expression = this.VisitExpression(insert.Expression); 
            insert.Row = (SqlRow)this.Visit(insert.Row);
            return insert; 
        }
        internal virtual SqlStatement VisitUpdate(SqlUpdate update) {
            update.Select = this.VisitSequence(update.Select);
            for (int i = 0, n = update.Assignments.Count; i < n; i++) { 
                update.Assignments[i] = (SqlAssign)this.Visit(update.Assignments[i]);
            } 
            return update; 
        }
        internal virtual SqlStatement VisitDelete(SqlDelete delete) { 
            delete.Select = this.VisitSequence(delete.Select);
            return delete;
        }
        internal virtual SqlMemberAssign VisitMemberAssign(SqlMemberAssign ma) { 
            ma.Expression = this.VisitExpression(ma.Expression);
            return ma; 
        } 
        internal virtual SqlStatement VisitAssign(SqlAssign sa) {
            sa.LValue = this.VisitExpression(sa.LValue); 
            sa.RValue = this.VisitExpression(sa.RValue);
            return sa;
        }
        internal virtual SqlBlock VisitBlock(SqlBlock b) { 
            for (int i = 0, n = b.Statements.Count; i < n; i++) {
                b.Statements[i] = (SqlStatement)this.Visit(b.Statements[i]); 
            } 
            return b;
        } 
        internal virtual SqlExpression VisitSearchedCase(SqlSearchedCase c) {
            for (int i = 0, n = c.Whens.Count; i < n; i++) {
                SqlWhen when = c.Whens[i];
                when.Match = this.VisitExpression(when.Match); 
                when.Value = this.VisitExpression(when.Value);
            } 
            c.Else = this.VisitExpression(c.Else); 
            return c;
        } 
        internal virtual SqlExpression VisitClientCase(SqlClientCase c) {
            c.Expression = this.VisitExpression(c.Expression);
            for (int i = 0, n = c.Whens.Count; i < n; i++) {
                SqlClientWhen when = c.Whens[i]; 
                when.Match = this.VisitExpression(when.Match);
                when.Value = this.VisitExpression(when.Value); 
            } 
            return c;
        } 
        internal virtual SqlExpression VisitSimpleCase(SqlSimpleCase c) {
            c.Expression = this.VisitExpression(c.Expression);
            for (int i = 0, n = c.Whens.Count; i < n; i++) {
                SqlWhen when = c.Whens[i]; 
                when.Match = this.VisitExpression(when.Match);
                when.Value = this.VisitExpression(when.Value); 
            } 
            return c;
        } 
        internal virtual SqlExpression VisitTypeCase(SqlTypeCase tc) {
            tc.Discriminator = this.VisitExpression(tc.Discriminator);
            for (int i = 0, n = tc.Whens.Count; i < n; i++) {
                SqlTypeCaseWhen when = tc.Whens[i]; 
                when.Match = this.VisitExpression(when.Match);
                when.TypeBinding = this.VisitExpression(when.TypeBinding); 
            } 
            return tc;
        } 
        internal virtual SqlNode VisitUnion(SqlUnion su) {
            su.Left = this.Visit(su.Left);
            su.Right = this.Visit(su.Right);
            return su; 
        }
        internal virtual SqlExpression VisitExprSet(SqlExprSet xs) { 
            for (int i = 0, n = xs.Expressions.Count; i < n; i++) { 
                xs.Expressions[i] = this.VisitExpression(xs.Expressions[i]);
            } 
            return xs;
        }
        internal virtual SqlExpression VisitVariable(SqlVariable v) {
            return v; 
        }
        internal virtual SqlExpression VisitOptionalValue(SqlOptionalValue sov) { 
            sov.HasValue = this.VisitExpression(sov.HasValue); 
            sov.Value = this.VisitExpression(sov.Value);
            return sov; 
        }
        internal virtual SqlExpression VisitBetween(SqlBetween between) {
            between.Expression = this.VisitExpression(between.Expression);
            between.Start = this.VisitExpression(between.Start); 
            between.End = this.VisitExpression(between.End);
            return between; 
        } 
        internal virtual SqlExpression VisitIn(SqlIn sin) {
            sin.Expression = this.VisitExpression(sin.Expression); 
            for (int i = 0, n = sin.Values.Count; i < n; i++) {
                sin.Values[i] = this.VisitExpression(sin.Values[i]);
            }
            return sin; 
        }
        internal virtual SqlExpression VisitLike(SqlLike like) { 
            like.Expression = this.VisitExpression(like.Expression); 
            like.Pattern = this.VisitExpression(like.Pattern);
            like.Escape = this.VisitExpression(like.Escape); 
            return like;
        }
        internal virtual SqlExpression VisitFunctionCall(SqlFunctionCall fc) {
            for (int i = 0, n = fc.Arguments.Count; i < n; i++) { 
                fc.Arguments[i] = this.VisitExpression(fc.Arguments[i]);
            } 
            return fc; 
        }
        internal virtual SqlExpression VisitTableValuedFunctionCall(SqlTableValuedFunctionCall fc) { 
            for (int i = 0, n = fc.Arguments.Count; i < n; i++) {
                fc.Arguments[i] = this.VisitExpression(fc.Arguments[i]);
            }
            return fc; 
        }
        internal virtual SqlExpression VisitMethodCall(SqlMethodCall mc) { 
            mc.Object = this.VisitExpression(mc.Object); 
            for (int i = 0, n = mc.Arguments.Count; i < n; i++) {
                mc.Arguments[i] = this.VisitExpression(mc.Arguments[i]); 
            }
            return mc;
        }
        internal virtual SqlExpression VisitSharedExpression(SqlSharedExpression shared) { 
            shared.Expression = this.VisitExpression(shared.Expression);
            return shared; 
        } 
        internal virtual SqlExpression VisitSharedExpressionRef(SqlSharedExpressionRef sref) {
            return sref; 
        }
        internal virtual SqlExpression VisitSimpleExpression(SqlSimpleExpression simple) {
            simple.Expression = this.VisitExpression(simple.Expression);
            return simple; 
        }
        internal virtual SqlExpression VisitGrouping(SqlGrouping g) { 
            g.Key = this.VisitExpression(g.Key); 
            g.Group = this.VisitExpression(g.Group);
            return g; 
        }
        internal virtual SqlExpression VisitDiscriminatedType(SqlDiscriminatedType dt) {
            dt.Discriminator = this.VisitExpression(dt.Discriminator);
            return dt; 
        }
        internal virtual SqlExpression VisitDiscriminatorOf(SqlDiscriminatorOf dof) { 
            dof.Object = this.VisitExpression(dof.Object); 
            return dof;
        } 
        internal virtual SqlNode VisitIncludeScope(SqlIncludeScope node) {
            node.Child = this.Visit(node.Child);
            return node;
        } 

#if DEBUG 
        int refersDepth; 
#endif
        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
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK