Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1478 lines
57 KiB
C#

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;
}
}
}
}