1478 lines
57 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|
|
}
|