mono/mcs/class/referencesource/System.Data.Linq/SqlClient/Query/SqlFormatter.cs

using System;
using System.Globalization;
using System.Collections.Generic;
using System.Data;
using System.Text;
using System.Data.Linq.Mapping;
using System.Data.Linq.Provider;
using System.Linq;
using System.Data.SqlClient;
using System.Diagnostics.CodeAnalysis;

namespace System.Data.Linq.SqlClient {

    internal class SqlFormatter : DbFormatter {
        private Visitor visitor;

        internal SqlFormatter() {
            this.visitor = new Visitor();
        }

        internal override string Format(SqlNode node, bool isDebug) {
            return this.visitor.Format(node, isDebug);
        }

        internal string[] FormatBlock(SqlBlock block, bool isDebug) {
            List<string> results = new List<string>(block.Statements.Count);
            for (int i = 0, n = block.Statements.Count; i < n; i++) {
                SqlStatement stmt = block.Statements[i];
                SqlSelect select = stmt as SqlSelect;
                if (select != null && select.DoNotOutput) {
                    continue;
                } else {
                    results.Add(this.Format(stmt, isDebug));
                }
            }
            return results.ToArray();
        }

        internal override string Format(SqlNode node) {
            return this.visitor.Format(node);
        }

        internal bool ParenthesizeTop {
            get { return this.visitor.parenthesizeTop; }
            set { this.visitor.parenthesizeTop = value; }
        }

        [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.")]
        internal class Visitor : SqlVisitor {
            internal StringBuilder sb;
            internal bool isDebugMode;
            internal List<SqlSource> suppressedAliases = new List<SqlSource>();
            internal Dictionary<SqlNode, string> names = new Dictionary<SqlNode, string>();
            internal Dictionary<SqlColumn, SqlAlias> aliasMap = new Dictionary<SqlColumn, SqlAlias>();
            internal int depth;
            internal bool parenthesizeTop;

            internal Visitor() {
            }

            internal string Format(SqlNode node, bool isDebug) {
                this.sb = new StringBuilder();
                this.isDebugMode = isDebug;
                this.aliasMap.Clear();
                if (isDebug) {
                    new AliasMapper(this.aliasMap).Visit(node);
                }
                this.Visit(node);
                return this.sb.ToString();
            }

            internal string Format(SqlNode node) {
                return this.Format(node, false);
            }

            [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 void VisitWithParens(SqlNode node, SqlNode outer) {
                if (node == null)
                    return;
                switch (node.NodeType) {
                    case SqlNodeType.ColumnRef:
                    case SqlNodeType.Value:
                    case SqlNodeType.Member:
                    case SqlNodeType.Parameter:
                    case SqlNodeType.FunctionCall:
                    case SqlNodeType.TableValuedFunctionCall:
                    case SqlNodeType.OuterJoinedValue:
                        this.Visit(node);
                        break;
                    case SqlNodeType.Add:
                    case SqlNodeType.Mul:
                    case SqlNodeType.And:
                    case SqlNodeType.Or:
                    case SqlNodeType.Not:
                    case SqlNodeType.Not2V:
                    case SqlNodeType.BitAnd:
                    case SqlNodeType.BitOr:
                    case SqlNodeType.BitXor:
                    case SqlNodeType.BitNot:
                        if (outer.NodeType != node.NodeType)
                            goto default;
                        this.Visit(node);
                        break;

                    default:
                        this.sb.Append("(");
                        this.Visit(node);
                        this.sb.Append(")");
                        break;
                }
            }

            internal override SqlExpression VisitNop(SqlNop nop) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("NOP");
                }
                sb.Append("NOP()");
                return nop;
            }

            [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 override SqlExpression VisitUnaryOperator(SqlUnary uo) {
                switch (uo.NodeType) {
                    case SqlNodeType.Not:
                    case SqlNodeType.Not2V:
                        this.sb.Append(GetOperator(uo.NodeType));
                        this.sb.Append(" ");
                        this.VisitWithParens(uo.Operand, uo);
                        break;
                    case SqlNodeType.Negate:
                    case SqlNodeType.BitNot:
                        this.sb.Append(GetOperator(uo.NodeType));
                        this.VisitWithParens(uo.Operand, uo);
                        break;
                    case SqlNodeType.Count:
                    case SqlNodeType.LongCount:
                    case SqlNodeType.Max:
                    case SqlNodeType.Min:
                    case SqlNodeType.Sum:
                    case SqlNodeType.Avg:
                    case SqlNodeType.Stddev:
                    case SqlNodeType.ClrLength:{
                            this.sb.Append(GetOperator(uo.NodeType));
                            this.sb.Append("(");
                            if (uo.Operand == null) {
                                this.sb.Append("*");
                            } else {
                                this.Visit(uo.Operand);
                            }
                            this.sb.Append(")");
                            break;
                        }
                    case SqlNodeType.IsNull:
                    case SqlNodeType.IsNotNull: {
                            this.VisitWithParens(uo.Operand, uo);
                            sb.Append(" ");
                            sb.Append(GetOperator(uo.NodeType));
                            break;
                        }
                    case SqlNodeType.Convert: {
                            this.sb.Append("CONVERT(");
                            QueryFormatOptions options = QueryFormatOptions.None; 
                            if(uo.Operand.SqlType.CanSuppressSizeForConversionToString) {
                                options = QueryFormatOptions.SuppressSize;
                            }
                            this.sb.Append(uo.SqlType.ToQueryString(options));
                            this.sb.Append(",");
                            this.Visit(uo.Operand);
                            this.sb.Append(")");
                            break;
                        }
                    case SqlNodeType.ValueOf:
                    case SqlNodeType.OuterJoinedValue:
                        this.Visit(uo.Operand); // no op
                        break;
                    default:
                        throw Error.InvalidFormatNode(uo.NodeType);
                }
                return uo;
            }

            internal override SqlRowNumber VisitRowNumber(SqlRowNumber rowNumber) {
                sb.Append("ROW_NUMBER() OVER (ORDER BY ");

                for (int i = 0, n = rowNumber.OrderBy.Count; i < n; i++) {
                    SqlOrderExpression exp = rowNumber.OrderBy[i];

                    if (i > 0) sb.Append(", ");

                    this.Visit(exp.Expression);

                    if (exp.OrderType == SqlOrderType.Descending) {
                        sb.Append(" DESC");
                    }
                }

                sb.Append(")");

                return rowNumber;
            }

            internal override SqlExpression VisitLift(SqlLift lift) {
                this.Visit(lift.Expression);
                return lift;
            }

            internal override SqlExpression VisitBinaryOperator(SqlBinary bo) {
                switch (bo.NodeType) {
                    case SqlNodeType.Coalesce:
                        sb.Append("COALESCE(");
                        this.Visit(bo.Left);
                        sb.Append(",");
                        this.Visit(bo.Right);
                        sb.Append(")");
                        break;
                    default:
                        this.VisitWithParens(bo.Left, bo);
                        sb.Append(" ");
                        sb.Append(GetOperator(bo.NodeType));
                        sb.Append(" ");
                        this.VisitWithParens(bo.Right, bo);
                        break;
                }
                return bo;
            }

            internal override SqlExpression VisitBetween(SqlBetween between) {
                this.VisitWithParens(between.Expression, between);
                sb.Append(" BETWEEN ");
                this.Visit(between.Start);
                sb.Append(" AND ");
                this.Visit(between.End);
                return between;
            }

            internal override SqlExpression VisitIn(SqlIn sin) {
                this.VisitWithParens(sin.Expression, sin);
                sb.Append(" IN (");
                for (int i = 0, n = sin.Values.Count; i < n; i++) {
                    if (i > 0) {
                        sb.Append(", ");
                    }
                    this.Visit(sin.Values[i]);
                }
                sb.Append(")");
                return sin;
            }

            internal override SqlExpression VisitLike(SqlLike like) {
                this.VisitWithParens(like.Expression, like);
                sb.Append(" LIKE ");
                this.Visit(like.Pattern);
                if (like.Escape != null) {
                    sb.Append(" ESCAPE ");
                    this.Visit(like.Escape);
                }
                return like;
            }

            internal override SqlExpression VisitFunctionCall(SqlFunctionCall fc) {
                if (fc.Name.Contains(".")) {
                    // Assume UDF -- bracket the name.
                    this.WriteName(fc.Name);
                } else {
                    // No ".", so we assume it's a system function name and leave it alone.
                    sb.Append(fc.Name);
                }
                
                sb.Append("(");
                for (int i = 0, n = fc.Arguments.Count; i < n; i++) {
                    if (i > 0)
                        sb.Append(", ");
                    this.Visit(fc.Arguments[i]);
                }
                sb.Append(")");
                return fc;
            }

            internal override SqlExpression VisitTableValuedFunctionCall(SqlTableValuedFunctionCall fc) {
                // both scalar and table valued functions are formatted the same
                return VisitFunctionCall(fc);
            }

            internal override SqlExpression VisitCast(SqlUnary c) {
                sb.Append("CAST(");
                this.Visit(c.Operand);
                sb.Append(" AS ");
                QueryFormatOptions options = QueryFormatOptions.None;
                if (c.Operand.SqlType.CanSuppressSizeForConversionToString) {
                    options = QueryFormatOptions.SuppressSize;
                }
                sb.Append(c.SqlType.ToQueryString(options));
                sb.Append(")");
                return c;
            }

            internal override SqlExpression VisitTreat(SqlUnary t) {
                sb.Append("TREAT(");
                this.Visit(t.Operand);
                sb.Append(" AS ");
                this.FormatType(t.SqlType);
                sb.Append(")");
                return t;
            }

            internal override SqlExpression VisitColumn(SqlColumn c) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("Column");
                }
                sb.Append("COLUMN(");
                if (c.Expression != null) {
                    this.Visit(c.Expression);
                }
                else {
                    string aliasName = null;
                    if (c.Alias != null) {
                        if (c.Alias.Name == null) {
                            if (!this.names.TryGetValue(c.Alias, out aliasName)) {
                                aliasName = "A" + this.names.Count;
                                this.names[c.Alias] = aliasName;
                            }
                        } else {
                            aliasName = c.Alias.Name;
                        }
                    }
                    sb.Append(aliasName);
                    sb.Append(".");
                    sb.Append(c.Name);
                }
                sb.Append(")");
                return c;
            }

            internal override SqlExpression VisitDiscriminatedType(SqlDiscriminatedType dt) {
                if (this.isDebugMode) {
                    sb.Append("DTYPE(");
                }
                base.VisitDiscriminatedType(dt);
                if (this.isDebugMode) {
                    sb.Append(")");
                }
                return dt;
            }

            internal override SqlExpression VisitDiscriminatorOf(SqlDiscriminatorOf dof) {
                if (this.isDebugMode) {
                    sb.Append("DISCO(");
                }
                base.VisitDiscriminatorOf(dof);
                if (this.isDebugMode) {
                    sb.Append(")");
                }
                return dof;
            }

            internal override SqlExpression VisitSimpleExpression(SqlSimpleExpression simple) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("SIMPLE");
                }
                sb.Append("SIMPLE(");
                base.VisitSimpleExpression(simple);
                sb.Append(")");
                return simple;
            }

            internal override SqlExpression VisitSharedExpression(SqlSharedExpression shared) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("Shared");
                }
                sb.Append("SHARED(");
                this.Visit(shared.Expression);
                sb.Append(")");
                return shared;
            }

            internal override SqlExpression VisitSharedExpressionRef(SqlSharedExpressionRef sref) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("SharedRef");
                }
                sb.Append("SHAREDREF(");
                this.Visit(sref.SharedExpression.Expression);
                sb.Append(")");
                return sref;
            }

            internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
                string aliasName = null;
                SqlColumn c = cref.Column;
                SqlAlias alias = c.Alias;
                if (alias == null) {
                    this.aliasMap.TryGetValue(c, out alias);
                }
                if (alias != null) {
                    if (alias.Name == null) {
                        if (!this.names.TryGetValue(alias, out aliasName)) {
                            aliasName = "A" + this.names.Count;
                            this.names[c.Alias] = aliasName;
                        }
                    } else {
                        aliasName = c.Alias.Name;
                    }
                }
                if (!this.suppressedAliases.Contains(c.Alias) && aliasName != null && aliasName.Length != 0) {
                    this.WriteName(aliasName);
                    sb.Append(".");
                }
                string name = c.Name;
                string inferredName = this.InferName(c.Expression, null);
                if (name == null)
                    name = inferredName;
                if (name == null) {
                    if (!this.names.TryGetValue(c, out name)) {
                        name = "C" + this.names.Count;
                        this.names[c] = name;
                    }
                }
                this.WriteName(name);
                return cref;
            }

            internal virtual void WriteName(string s) {
                sb.Append(SqlIdentifier.QuoteCompoundIdentifier(s));
            }

            internal virtual void WriteVariableName(string s) {
                if (s.StartsWith("@",StringComparison.Ordinal))
                    sb.Append(SqlIdentifier.QuoteCompoundIdentifier(s));
                else
                    sb.Append(SqlIdentifier.QuoteCompoundIdentifier("@" + s));
            }

            internal override SqlExpression VisitParameter(SqlParameter p) {
                sb.Append(p.Name);
                return p;
            }

            internal override SqlExpression VisitValue(SqlValue value) {
                if (value.IsClientSpecified && !this.isDebugMode) {
                    throw Error.InvalidFormatNode("Value");
                }
                else {
                    this.FormatValue(value.Value);
                }
                return value;
            }

            internal override SqlExpression VisitClientParameter(SqlClientParameter cp) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("ClientParameter");
                }
                else {
                    sb.Append("client-parameter(");
                    object value;
                    try {
                        value = cp.Accessor.Compile().DynamicInvoke(new object[] { null });
                    } catch (System.Reflection.TargetInvocationException e) {
                        throw e.InnerException;
                    }

                    sb.Append(value);
                    sb.Append(")");
                }
                return cp;
            }

            internal override SqlExpression VisitScalarSubSelect(SqlSubSelect ss) {
                int saveDepth = this.depth;
                this.depth++;
                if (this.isDebugMode) {
                    sb.Append("SCALAR");
                }
                sb.Append("(");
                this.NewLine();
                this.Visit(ss.Select);
                this.NewLine();
                sb.Append(")");
                this.depth = saveDepth;
                return ss;
            }

            internal override SqlExpression VisitElement(SqlSubSelect elem) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("Element");
                }
                int saveDepth = this.depth;
                this.depth++;
                sb.Append("ELEMENT(");
                this.NewLine();
                this.Visit(elem.Select);
                this.NewLine();
                sb.Append(")");
                this.depth = saveDepth;
                return elem;
            }

            internal override SqlExpression VisitMultiset(SqlSubSelect sms) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("Multiset");
                }
                int saveDepth = this.depth;
                this.depth++;
                sb.Append("MULTISET(");
                this.NewLine();
                this.Visit(sms.Select);
                this.NewLine();
                sb.Append(")");
                this.depth = saveDepth;
                return sms;
            }

            internal override SqlExpression VisitExists(SqlSubSelect sqlExpr) {
                int saveDepth = this.depth;
                this.depth++;
                sb.Append("EXISTS(");
                this.NewLine();
                this.Visit(sqlExpr.Select);
                this.NewLine();
                sb.Append(")");
                this.depth = saveDepth;
                return sqlExpr;
            }

            internal override SqlTable VisitTable(SqlTable tab) {
                string name = tab.Name;
                this.WriteName(name);
                return tab;
            }

            internal override SqlUserQuery VisitUserQuery(SqlUserQuery suq) {
                if (suq.Arguments.Count > 0) {
                    // compute all the arg values...
                    StringBuilder savesb = this.sb;
                    this.sb = new StringBuilder();
                    object[] args = new object[suq.Arguments.Count];
                    for (int i = 0, n = args.Length; i < n; i++) {
                        this.Visit(suq.Arguments[i]);
                        args[i] = this.sb.ToString();
                        this.sb.Length = 0;
                    }
                    this.sb = savesb;
                    // append query with args...
                    sb.Append(string.Format(CultureInfo.InvariantCulture, suq.QueryText, args));
                } else {
                    sb.Append(suq.QueryText);
                }
                return suq;
            }

            internal override SqlExpression VisitUserColumn(SqlUserColumn suc) {
                sb.Append(suc.Name);
                return suc;
            }

            internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) {
                sb.Append("EXEC @RETURN_VALUE = ");
                this.WriteName(spc.Function.MappedName);
                sb.Append(" ");

                int pc = spc.Function.Parameters.Count;
                System.Diagnostics.Debug.Assert(spc.Arguments.Count >= pc);

                for (int i = 0;  i < pc; i++) {
                    MetaParameter mp = spc.Function.Parameters[i];
                    if (i > 0) sb.Append(", ");
                    this.WriteVariableName(mp.MappedName);
                    sb.Append(" = ");
                    this.Visit(spc.Arguments[i]);
                    if (mp.Parameter.IsOut || mp.Parameter.ParameterType.IsByRef)
                        sb.Append(" OUTPUT");
                }

                if (spc.Arguments.Count > pc) {
                    if (pc > 0) sb.Append(", ");
                    this.WriteVariableName(spc.Function.ReturnParameter.MappedName);
                    sb.Append(" = ");
                    this.Visit(spc.Arguments[pc]);
                    sb.Append(" OUTPUT");
                }

                return spc;
            }

            internal override SqlAlias VisitAlias(SqlAlias alias) {
                bool isSelect = alias.Node is SqlSelect;
                int saveDepth = this.depth;
                string aliasName = null;
                string name = "";
                SqlTable table = alias.Node as SqlTable;
                if (table != null) {
                    name = table.Name;
                }
                if (alias.Name == null) {
                    if (!this.names.TryGetValue(alias, out aliasName)) {
                        aliasName = "A" + this.names.Count;
                        this.names[alias] = aliasName;
                    }
                } else {
                    aliasName = alias.Name;
                }
                if (isSelect) {
                    this.depth++;
                    sb.Append("(");
                    this.NewLine();
                }
                this.Visit(alias.Node);
                if (isSelect) {
                    this.NewLine();
                    sb.Append(")");
                    this.depth = saveDepth;
                }
                if (!this.suppressedAliases.Contains(alias) && aliasName != null && name != aliasName) {
                    sb.Append(" AS ");
                    this.WriteName(aliasName);
                }
                return alias;
            }

            internal override SqlExpression VisitAliasRef(SqlAliasRef aref) {
                sb.Append("AREF(");
                this.WriteAliasName(aref.Alias);
                sb.Append(")");
                return aref;
            }

            private void WriteAliasName(SqlAlias alias) {
                string aliasName = null;
                if (alias.Name == null) {
                    if (!this.names.TryGetValue(alias, out aliasName)) {
                        aliasName = "A" + this.names.Count;
                        this.names[alias] = aliasName;
                    }
                }
                else {
                    aliasName = alias.Name;
                }
                this.WriteName(aliasName);
            }

            internal override SqlNode VisitUnion(SqlUnion su) {
                sb.Append("(");
                int saveDepth = this.depth;
                this.depth++;
                this.NewLine();
                this.Visit(su.Left);
                this.NewLine();
                sb.Append("UNION");
                if (su.All) {
                    sb.Append(" ALL");
                }
                this.NewLine();
                this.Visit(su.Right);
                this.NewLine();
                sb.Append(")");
                this.depth = saveDepth;
                return su;
            }

            internal override SqlExpression VisitExprSet(SqlExprSet xs) {
                if (this.isDebugMode) {
                    sb.Append("ES(");
                    for (int i = 0, n = xs.Expressions.Count; i < n; i++) {
                        if (i > 0)
                            sb.Append(", ");
                        this.Visit(xs.Expressions[i]);
                    }
                    sb.Append(")");
                } else {
                    // only show the first one
                    this.Visit(xs.GetFirstExpression());
                }
                return xs;
            }

            internal override SqlRow VisitRow(SqlRow row) {
                for (int i = 0, n = row.Columns.Count; i < n; i++) {
                    SqlColumn c = row.Columns[i];
                    if (i > 0)
                        sb.Append(", ");
                    this.Visit(c.Expression);
                    string name = c.Name;
                    string inferredName = this.InferName(c.Expression, null);
                    if (name == null)
                        name = inferredName;
                    if (name == null) {
                        if (!this.names.TryGetValue(c, out name)) {
                            name = "C" + this.names.Count;
                            this.names[c] = name;
                        }
                    }
                    if (name != inferredName && !String.IsNullOrEmpty(name)) {
                        sb.Append(" AS ");
                        this.WriteName(name);
                    }
                }
                return row;
            }

            internal override SqlExpression VisitNew(SqlNew sox) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("New");
                }
                sb.Append("new ");
                sb.Append(sox.ClrType.Name);
                sb.Append("{ ");
                // Visit Args
                for (int i = 0, n = sox.Args.Count; i < n; i++)
                {
                    SqlExpression argExpr = sox.Args[i];
                    if (i > 0) sb.Append(", ");
                    sb.Append(sox.ArgMembers[i].Name);
                    sb.Append(" = ");
                    this.Visit(argExpr);
                }
                // Visit Members
                for (int i = 0, n = sox.Members.Count; i < n; i++) {
                    SqlMemberAssign ma = sox.Members[i];
                    if (i > 0) sb.Append(", ");
                    string ename = this.InferName(ma.Expression, null);
                    if (ename != ma.Member.Name) {
                        sb.Append(ma.Member.Name);
                        sb.Append(" = ");
                    }
                    this.Visit(ma.Expression);
                }
                sb.Append(" }");
                return sox;
            }

            internal override SqlExpression VisitClientArray(SqlClientArray scar) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("ClientArray");
                }
                sb.Append("new []{");
                for (int i = 0, n = scar.Expressions.Count; i < n; i++) {
                    if (i > 0) sb.Append(", ");
                    this.Visit(scar.Expressions[i]);
                }
                sb.Append("}");
                return scar;
            }

            internal override SqlNode VisitMember(SqlMember m) {
                this.Visit(m.Expression);
                sb.Append(".");
                sb.Append(m.Member.Name);
                return m;
            }

            internal virtual void NewLine() {
                if (sb.Length > 0) {
                    sb.AppendLine();
                }
                for (int i = 0; i < this.depth; i++) {
                    sb.Append("    ");
                }
            }

            internal override SqlSelect VisitSelect(SqlSelect ss) {
                if (ss.DoNotOutput) {
                    return ss;
                }
                string from = null;
                if (ss.From != null) {
                    StringBuilder savesb = this.sb;
                    this.sb = new StringBuilder();
                    if (this.IsSimpleCrossJoinList(ss.From)) {
                        this.VisitCrossJoinList(ss.From);
                    } else {
                        this.Visit(ss.From);
                    }
                    from = this.sb.ToString();
                    this.sb = savesb;
                }

                sb.Append("SELECT ");

                if (ss.IsDistinct) {
                    sb.Append("DISTINCT ");
                }

                if (ss.Top != null) {
                    sb.Append("TOP ");
                    if (this.parenthesizeTop) {
                        sb.Append("(");
                    }
                    this.Visit(ss.Top);
                    if (this.parenthesizeTop) {
                        sb.Append(")");
                    }
                    sb.Append(" ");
                    if (ss.IsPercent) {
                        sb.Append(" PERCENT ");
                    }
                }

                if (ss.Row.Columns.Count > 0) {
                    this.VisitRow(ss.Row);
                } else if (this.isDebugMode) {
                    this.Visit(ss.Selection);
                } else {
                    sb.Append("NULL AS [EMPTY]");
                }

                if (from != null) {
                    this.NewLine();
                    sb.Append("FROM ");
                    sb.Append(from);
                }
                if (ss.Where != null) {
                    this.NewLine();
                    sb.Append("WHERE ");
                    this.Visit(ss.Where);
                }
                if (ss.GroupBy.Count > 0) {
                    this.NewLine();
                    sb.Append("GROUP BY ");
                    for (int i = 0, n = ss.GroupBy.Count; i < n; i++) {
                        SqlExpression exp = ss.GroupBy[i];
                        if (i > 0)
                            sb.Append(", ");
                        this.Visit(exp);
                    }
                    if (ss.Having != null) {
                        this.NewLine();
                        sb.Append("HAVING ");
                        this.Visit(ss.Having);
                    }
                }
                if (ss.OrderBy.Count > 0 && ss.OrderingType != SqlOrderingType.Never) {
                    this.NewLine();
                    sb.Append("ORDER BY ");
                    for (int i = 0, n = ss.OrderBy.Count; i < n; i++) {
                        SqlOrderExpression exp = ss.OrderBy[i];
                        if (i > 0)
                            sb.Append(", ");
                        this.Visit(exp.Expression);
                        if (exp.OrderType == SqlOrderType.Descending) {
                            sb.Append(" DESC");
                        }
                    }
                }

                return ss;
            }

            internal virtual bool IsSimpleCrossJoinList(SqlNode node) {
                SqlJoin join = node as SqlJoin;
                if (join != null) {
                    return join.JoinType == SqlJoinType.Cross &&
                        this.IsSimpleCrossJoinList(join.Left) &&
                        this.IsSimpleCrossJoinList(join.Right);
                }
                SqlAlias alias = node as SqlAlias;
                return (alias != null && alias.Node is SqlTable);
            }

            internal virtual void VisitCrossJoinList(SqlNode node) {
                SqlJoin join = node as SqlJoin;
                if (join != null) {
                    this.VisitCrossJoinList(join.Left);
                    sb.Append(", ");
                    this.VisitCrossJoinList(join.Right);
                } else {
                    this.Visit(node);
                }
            }

            internal void VisitJoinSource(SqlSource src) {
                if (src.NodeType == SqlNodeType.Join) {
                    this.depth++;
                    sb.Append("(");
                    this.Visit(src);
                    sb.Append(")");
                    this.depth--;
                } else {
                    this.Visit(src);
                }
            }

            internal override SqlSource VisitJoin(SqlJoin join) {
                this.Visit(join.Left);
                this.NewLine();
                switch (join.JoinType) {
                    case SqlJoinType.CrossApply:
                        sb.Append("CROSS APPLY ");
                        break;
                    case SqlJoinType.Cross:
                        sb.Append("CROSS JOIN ");
                        break;
                    case SqlJoinType.Inner:
                        sb.Append("INNER JOIN ");
                        break;
                    case SqlJoinType.LeftOuter:
                        sb.Append("LEFT OUTER JOIN ");
                        break;
                    case SqlJoinType.OuterApply:
                        sb.Append("OUTER APPLY ");
                        break;
                }
                SqlJoin rightJoin = join.Right as SqlJoin;
                if (rightJoin == null || 
                     (rightJoin.JoinType == SqlJoinType.Cross 
                       && join.JoinType != SqlJoinType.CrossApply 
                       && join.JoinType != SqlJoinType.OuterApply)) {
                    this.Visit(join.Right);
                } else {
                    this.VisitJoinSource(join.Right);
                }
                if (join.Condition != null) {
                    sb.Append(" ON ");
                    this.Visit(join.Condition);
                } else if (this.RequiresOnCondition(join.JoinType)) {
                    sb.Append(" ON 1=1 ");
                }
                return join;
            }

            [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
            internal bool RequiresOnCondition(SqlJoinType joinType) {
                switch (joinType) {
                    case SqlJoinType.CrossApply:
                    case SqlJoinType.Cross:
                    case SqlJoinType.OuterApply:
                        return false;
                    case SqlJoinType.Inner:
                    case SqlJoinType.LeftOuter:
                        return true;
                    default:
                        throw Error.InvalidFormatNode(joinType);
                }
            }

            internal override SqlBlock VisitBlock(SqlBlock block) {
                for (int i = 0, n = block.Statements.Count; i < n; i++) {
                    this.Visit(block.Statements[i]);
                    if (i < n - 1) {
                        SqlSelect select = block.Statements[i+1] as SqlSelect;
                        if (select == null || !select.DoNotOutput) {
                            this.NewLine();
                            this.NewLine();
                        }
                    }
                }
                return block;
            }

            internal override SqlExpression VisitClientQuery(SqlClientQuery cq) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("ClientQuery");
                }
                sb.Append("client(");
                for (int i = 0, n = cq.Arguments.Count; i < n; i++) {
                    if (i > 0) sb.Append(", ");
                    this.Visit(cq.Arguments[i]);
                }
                sb.Append("; ");
                this.Visit(cq.Query);
                sb.Append(")");
                return cq;
            }

            internal override SqlExpression VisitJoinedCollection(SqlJoinedCollection jc) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("JoinedCollection");
                }
                sb.Append("big-join(");
                this.Visit(jc.Expression);
                sb.Append(", ");
                this.Visit(jc.Count);
                sb.Append(")");
                return jc;
            }

            internal override SqlStatement VisitDelete(SqlDelete sd) {
                sb.Append("DELETE FROM ");
                this.suppressedAliases.Add(sd.Select.From);
                this.Visit(sd.Select.From);
                if (sd.Select.Where != null) {
                    sb.Append(" WHERE ");
                    this.Visit(sd.Select.Where);
                }
                this.suppressedAliases.Remove(sd.Select.From);
                return sd;
            }

            internal override SqlStatement VisitInsert(SqlInsert si) {

                if (si.OutputKey != null) {
                    sb.Append("DECLARE @output TABLE(");
                    this.WriteName(si.OutputKey.Name);
                    sb.Append(" ");
                    sb.Append(si.OutputKey.SqlType.ToQueryString());
                    sb.Append(")");
                    this.NewLine();
                    if (si.OutputToLocal) {
                        sb.Append("DECLARE @id ");
                        sb.Append(si.OutputKey.SqlType.ToQueryString());
                        this.NewLine();
                    }
                }

                sb.Append("INSERT INTO ");
                this.Visit(si.Table);

                if (si.Row.Columns.Count != 0) {
                    // INSERT INTO table (...columns...) VALUES (...values...)
                    sb.Append("(");
                    for (int i = 0, n = si.Row.Columns.Count; i < n; i++) {
                        if (i > 0) sb.Append(", ");
                        this.WriteName(si.Row.Columns[i].Name);
                    }
                    sb.Append(")");
                }

                if (si.OutputKey != null) {
                    this.NewLine();
                    sb.Append("OUTPUT INSERTED.");
                    this.WriteName(si.OutputKey.MetaMember.MappedName);
                    sb.Append(" INTO @output");
                }

                if (si.Row.Columns.Count == 0) {
                    sb.Append(" DEFAULT VALUES");
                }
                else {
                    // VALUES (...values...)
                    this.NewLine();
                    sb.Append("VALUES (");
                    if (this.isDebugMode && si.Row.Columns.Count == 0) {
                        this.Visit(si.Expression);
                    } else {
                        for (int i = 0, n = si.Row.Columns.Count; i < n; i++) {
                            if (i > 0) sb.Append(", ");
                            this.Visit( si.Row.Columns[i].Expression);
                        }
                    }
                    sb.Append(")");
                }

                if (si.OutputKey != null) {
                    this.NewLine();
                    if (si.OutputToLocal) {
                        sb.Append("SELECT @id = ");
                        sb.Append(si.OutputKey.Name);
                        sb.Append(" FROM @output");
                    }
                    else {
                        sb.Append("SELECT ");
                        this.WriteName(si.OutputKey.Name);
                        sb.Append(" FROM @output");
                    }
                }

                return si;
            }

            internal override SqlStatement VisitUpdate(SqlUpdate su) {
                sb.Append("UPDATE ");
                this.suppressedAliases.Add(su.Select.From);
                this.Visit(su.Select.From);
                this.NewLine();
                sb.Append("SET ");

                for (int i = 0, n = su.Assignments.Count; i < n; i++) {
                    if (i > 0) sb.Append(", ");
                    SqlAssign sa = su.Assignments[i];
                    this.Visit(sa.LValue);
                    sb.Append(" = ");
                    this.Visit(sa.RValue);
                }
                if (su.Select.Where != null) {
                    this.NewLine();
                    sb.Append("WHERE ");
                    this.Visit(su.Select.Where);
                }
                this.suppressedAliases.Remove(su.Select.From);
                return su;
            }

            internal override SqlStatement VisitAssign(SqlAssign sa) {
                sb.Append("SET ");
                this.Visit(sa.LValue);
                sb.Append(" = ");
                this.Visit(sa.RValue);
                return sa;
            }

            internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) {
                this.depth++;
                this.NewLine();
                sb.Append("(CASE ");
                this.depth++;
                for (int i = 0, n = c.Whens.Count; i < n; i++) {
                    SqlWhen when = c.Whens[i];
                    this.NewLine();
                    sb.Append("WHEN ");
                    this.Visit(when.Match);
                    sb.Append(" THEN ");
                    this.Visit(when.Value);
                }
                if (c.Else != null) {
                    this.NewLine();
                    sb.Append("ELSE ");
                    this.Visit(c.Else);
                }
                this.depth--;
                this.NewLine();
                sb.Append(" END)");
                this.depth--;
                return c;
            }

            internal override SqlExpression VisitSimpleCase(SqlSimpleCase c) {
                this.depth++;
                this.NewLine();
                sb.Append("(CASE");
                this.depth++;
                if (c.Expression != null) {
                    sb.Append(" ");
                    this.Visit(c.Expression);
                }
                for (int i = 0, n = c.Whens.Count; i < n; i++) {
                    SqlWhen when = c.Whens[i];
                    if (i == n - 1 && when.Match == null) {
                        this.NewLine();
                        sb.Append("ELSE ");
                        this.Visit(when.Value);
                    } else {
                        this.NewLine();
                        sb.Append("WHEN ");
                        this.Visit(when.Match);
                        sb.Append(" THEN ");
                        this.Visit(when.Value);
                    }
                }
                this.depth--;
                this.NewLine();
                sb.Append(" END)");
                this.depth--;
                return c;
            }

            internal override SqlExpression VisitClientCase(SqlClientCase c) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("ClientCase");
                }
                this.depth++;
                this.NewLine();
                sb.Append("(CASE");
                this.depth++;
                if (c.Expression != null) {
                    sb.Append(" ");
                    this.Visit(c.Expression);
                }
                for (int i = 0, n = c.Whens.Count; i < n; i++) {
                    SqlClientWhen when = c.Whens[i];
                    if (i == n - 1 && when.Match == null) {
                        this.NewLine();
                        sb.Append("ELSE ");
                        this.Visit(when.Value);
                    } else {
                        this.NewLine();
                        sb.Append("WHEN ");
                        this.Visit(when.Match);
                        sb.Append(" THEN ");
                        this.Visit(when.Value);
                    }
                }
                this.depth--;
                this.NewLine();
                sb.Append(" END)");
                this.depth--;
                return c;
            }

            internal override SqlExpression VisitTypeCase(SqlTypeCase c) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("TypeCase");
                }
                this.depth++;
                this.NewLine();
                sb.Append("(CASE");
                this.depth++;
                if (c.Discriminator != null) {
                    sb.Append(" ");
                    this.Visit(c.Discriminator);
                }
                for (int i = 0, n = c.Whens.Count; i < n; i++) {
                    SqlTypeCaseWhen when = c.Whens[i];
                    if (i == n - 1 && when.Match == null) {
                        this.NewLine();
                        sb.Append("ELSE ");
                        this.Visit(when.TypeBinding);
                    } else {
                        this.NewLine();
                        sb.Append("WHEN ");
                        this.Visit(when.Match);
                        sb.Append(" THEN ");
                        this.Visit(when.TypeBinding);
                    }
                }
                this.depth--;
                this.NewLine();
                sb.Append(" END)");
                this.depth--;
                return c;
            }

            internal override SqlExpression VisitVariable(SqlVariable v) {
                sb.Append(v.Name);
                return v;
            }

            private string InferName(SqlExpression exp, string def) {
                if (exp == null) return null;
                switch (exp.NodeType) {
                    case SqlNodeType.Member:
                        return ((SqlMember)exp).Member.Name;
                    case SqlNodeType.Column:
                        return ((SqlColumn)exp).Name;
                    case SqlNodeType.ColumnRef:
                        return ((SqlColumnRef)exp).Column.Name;
                    case SqlNodeType.ExprSet:
                        return this.InferName(((SqlExprSet)exp).Expressions[0], def);
                    default:
                        return def;
                }
            }

            private void FormatType(ProviderType type) {
                sb.Append(type.ToQueryString());
            }

            [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 void FormatValue(object value) {
                if (value == null) {
                    sb.Append("NULL");
                } else {
                    Type t = value.GetType();
                    if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>))
                        t = t.GetGenericArguments()[0];
                    TypeCode tc = Type.GetTypeCode(t);
                    switch (tc) {
                        case TypeCode.Char:
                        case TypeCode.String:
                        case TypeCode.DateTime:
                            sb.Append("'");
                            sb.Append(this.EscapeSingleQuotes(value.ToString()));
                            sb.Append("'");
                            return;
                        case TypeCode.Boolean:
                            sb.Append(this.GetBoolValue((bool)value));
                            return;
                        case TypeCode.Byte:
                        case TypeCode.Decimal:
                        case TypeCode.Double:
                        case TypeCode.Int16:
                        case TypeCode.Int32:
                        case TypeCode.Int64:
                        case TypeCode.SByte:
                        case TypeCode.Single:
                        case TypeCode.UInt16:
                        case TypeCode.UInt32:
                        case TypeCode.UInt64:
                            sb.Append(value);
                            return;
                        case TypeCode.Object: {
                                if (value is Guid) {
                                    sb.Append("'");
                                    sb.Append(value);
                                    sb.Append("'");
                                    return;
                                }
                                Type valueType = value as Type;
                                if (valueType != null) {
                                    if (this.isDebugMode) {
                                        sb.Append("typeof(");
                                        sb.Append(valueType.Name);
                                        sb.Append(")");
                                    } else {
                                        this.FormatValue("");
                                    }
                                    return;
                                }
                                break;
                            }
                    }
                    if (this.isDebugMode) {
                        sb.Append("value(");
                        sb.Append(value.ToString());
                        sb.Append(")");
                    }
                    else {
                        throw Error.ValueHasNoLiteralInSql(value);
                    }
                }
            }

            internal virtual string GetBoolValue(bool value) {
                return value ? "1" : "0";
            }

            internal virtual string EscapeSingleQuotes(string str) {
                if (str.IndexOf('\'') < 0) return str;
                StringBuilder tempStringBuilder = new StringBuilder();
                foreach (char c in str) {
                    if (c == '\'') {
                        tempStringBuilder.Append("''");
                    } else {
                        tempStringBuilder.Append("'");
                    }
                }
                return tempStringBuilder.ToString();
            }

            [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 string GetOperator(SqlNodeType nt) {
                switch (nt) {
                    case SqlNodeType.Add: return "+";
                    case SqlNodeType.Sub: return "-";
                    case SqlNodeType.Mul: return "*";
                    case SqlNodeType.Div: return "/";
                    case SqlNodeType.Mod: return "%";
                    case SqlNodeType.Concat: return "+";
                    case SqlNodeType.BitAnd: return "&";
                    case SqlNodeType.BitOr: return "|";
                    case SqlNodeType.BitXor: return "^";
                    case SqlNodeType.And: return "AND";
                    case SqlNodeType.Or: return "OR";
                    case SqlNodeType.GE: return ">=";
                    case SqlNodeType.GT: return ">";
                    case SqlNodeType.LE: return "<=";
                    case SqlNodeType.LT: return "<";
                    case SqlNodeType.EQ: return "=";
                    case SqlNodeType.EQ2V: return "=";
                    case SqlNodeType.NE: return "<>";
                    case SqlNodeType.NE2V: return "<>";
                    case SqlNodeType.Not: return "NOT";
                    case SqlNodeType.Not2V: return "NOT";
                    case SqlNodeType.BitNot: return "~";
                    case SqlNodeType.Negate: return "-";
                    case SqlNodeType.IsNull: return "IS NULL";
                    case SqlNodeType.IsNotNull: return "IS NOT NULL";
                    case SqlNodeType.Count: return "COUNT";
                    case SqlNodeType.LongCount: return "COUNT_BIG";
                    case SqlNodeType.Min: return "MIN";
                    case SqlNodeType.Max: return "MAX";
                    case SqlNodeType.Sum: return "SUM";
                    case SqlNodeType.Avg: return "AVG";
                    case SqlNodeType.Stddev: return "STDEV";
                    case SqlNodeType.ClrLength: return "CLRLENGTH";
                    default:
                        throw Error.InvalidFormatNode(nt);
                }
            }

            internal override SqlNode VisitLink(SqlLink link) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("Link");
                }
                if (link.Expansion != null) {
                    sb.Append("LINK(");
                    this.Visit(link.Expansion);
                    sb.Append(")");
                } else {
                    sb.Append("LINK(");
                    for (int i = 0, n = link.KeyExpressions.Count; i < n; i++) {
                        if (i > 0) sb.Append(", ");
                        this.Visit(link.KeyExpressions[i]);
                    }
                    sb.Append(")");
                }
                return link;
            }

            internal override SqlMemberAssign VisitMemberAssign(SqlMemberAssign ma) {
                throw Error.InvalidFormatNode("MemberAssign");
            }

            internal override SqlExpression VisitMethodCall(SqlMethodCall mc) {
                if (!this.isDebugMode) {
                    throw Error.InvalidFormatNode("MethodCall");
                }
                if (mc.Method.IsStatic) {
                    sb.Append(mc.Method.DeclaringType);
                } else {
                    this.Visit(mc.Object);
                }
                sb.Append(".");
                sb.Append(mc.Method.Name);
                sb.Append("(");
                for (int i = 0, n = mc.Arguments.Count; i < n; i++) {
                    if (i > 0) sb.Append(", ");
                    this.Visit(mc.Arguments[i]);
                }
                sb.Append(")");
                return mc;
            }

            internal override SqlExpression VisitOptionalValue(SqlOptionalValue sov) {
                if (this.isDebugMode) {
                    sb.Append("opt(");
                    this.Visit(sov.HasValue);
                    sb.Append(", ");
                    this.Visit(sov.Value);
                    sb.Append(")");
                    return sov;
                } else {
                    throw Error.InvalidFormatNode("OptionalValue");
                }
            }

            internal override SqlExpression VisitUserRow(SqlUserRow row) {
                if (!isDebugMode) {
                    throw Error.InvalidFormatNode("UserRow");
                }
                return row;
            }

            internal override SqlExpression VisitGrouping(SqlGrouping g) {
                if (!isDebugMode) {
                    throw Error.InvalidFormatNode("Grouping");
                }
                sb.Append("Group(");
                this.Visit(g.Key);
                sb.Append(", ");
                this.Visit(g.Group);
                sb.Append(")");
                return g;
            }
        }

        class AliasMapper : SqlVisitor {
            Dictionary<SqlColumn, SqlAlias> aliasMap;
            SqlAlias currentAlias;

            internal AliasMapper(Dictionary<SqlColumn, SqlAlias> aliasMap) {
                this.aliasMap = aliasMap;
            }

            internal override SqlAlias VisitAlias(SqlAlias a) {
                SqlAlias save = this.currentAlias;
                this.currentAlias = a;
                base.VisitAlias(a);
                this.currentAlias = save;
                return a;
            }

            internal override SqlExpression VisitColumn(SqlColumn col) {
                this.aliasMap[col] = this.currentAlias;
                this.Visit(col.Expression);
                return col;
            }

            internal override SqlRow VisitRow(SqlRow row) {
                foreach(SqlColumn col in row.Columns) {
                    this.VisitColumn(col);
                }
                return row;
            }

            internal override SqlTable VisitTable(SqlTable tab) {
                foreach(SqlColumn col in tab.Columns) {
                    this.VisitColumn(col);
                }
                return tab;
            }

            internal override SqlExpression VisitTableValuedFunctionCall(SqlTableValuedFunctionCall fc) {
                foreach(SqlColumn col in fc.Columns) {
                    this.VisitColumn(col);
                }
                return fc;
            }
        }
    }
}