mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
449 lines
24 KiB
C#
449 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data.Linq;
|
|
using System.Data.Linq.Provider;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
namespace System.Data.Linq.SqlClient {
|
|
|
|
internal class SqlDuplicator {
|
|
DuplicatingVisitor superDuper;
|
|
|
|
internal SqlDuplicator()
|
|
: this(true) {
|
|
}
|
|
|
|
internal SqlDuplicator(bool ignoreExternalRefs) {
|
|
this.superDuper = new DuplicatingVisitor(ignoreExternalRefs);
|
|
}
|
|
|
|
internal static SqlNode Copy(SqlNode node) {
|
|
if (node == null)
|
|
return null;
|
|
switch (node.NodeType) {
|
|
case SqlNodeType.ColumnRef:
|
|
case SqlNodeType.Value:
|
|
case SqlNodeType.Parameter:
|
|
case SqlNodeType.Variable:
|
|
return node;
|
|
default:
|
|
return new SqlDuplicator().Duplicate(node);
|
|
}
|
|
}
|
|
|
|
internal SqlNode Duplicate(SqlNode node) {
|
|
return this.superDuper.Visit(node);
|
|
}
|
|
|
|
[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 DuplicatingVisitor : SqlVisitor {
|
|
Dictionary<SqlNode, SqlNode> nodeMap;
|
|
bool ingoreExternalRefs;
|
|
|
|
internal DuplicatingVisitor(bool ignoreExternalRefs) {
|
|
this.ingoreExternalRefs = ignoreExternalRefs;
|
|
this.nodeMap = new Dictionary<SqlNode, SqlNode>();
|
|
}
|
|
|
|
internal override SqlNode Visit(SqlNode node) {
|
|
if (node == null) {
|
|
return null;
|
|
}
|
|
SqlNode result = null;
|
|
if (this.nodeMap.TryGetValue(node, out result)) {
|
|
return result;
|
|
}
|
|
result = base.Visit(node);
|
|
this.nodeMap[node] = result;
|
|
return result;
|
|
}
|
|
internal override SqlExpression VisitDoNotVisit(SqlDoNotVisitExpression expr) {
|
|
// duplicator can duplicate through a do-no-visit node
|
|
return new SqlDoNotVisitExpression(this.VisitExpression(expr.Expression));
|
|
}
|
|
internal override SqlAlias VisitAlias(SqlAlias a) {
|
|
SqlAlias n = new SqlAlias(a.Node);
|
|
this.nodeMap[a] = n;
|
|
n.Node = this.Visit(a.Node);
|
|
n.Name = a.Name;
|
|
return n;
|
|
}
|
|
internal override SqlExpression VisitAliasRef(SqlAliasRef aref) {
|
|
if (this.ingoreExternalRefs && !this.nodeMap.ContainsKey(aref.Alias)) {
|
|
return aref;
|
|
}
|
|
return new SqlAliasRef((SqlAlias)this.Visit(aref.Alias));
|
|
}
|
|
internal override SqlRowNumber VisitRowNumber(SqlRowNumber rowNumber) {
|
|
List<SqlOrderExpression> orderBy = new List<SqlOrderExpression>();
|
|
|
|
foreach (SqlOrderExpression expr in rowNumber.OrderBy) {
|
|
orderBy.Add(new SqlOrderExpression(expr.OrderType, (SqlExpression)this.Visit(expr.Expression)));
|
|
}
|
|
|
|
return new SqlRowNumber(rowNumber.ClrType, rowNumber.SqlType, orderBy, rowNumber.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitBinaryOperator(SqlBinary bo) {
|
|
SqlExpression left = (SqlExpression)this.Visit(bo.Left);
|
|
SqlExpression right = (SqlExpression)this.Visit(bo.Right);
|
|
return new SqlBinary(bo.NodeType, bo.ClrType, bo.SqlType, left, right, bo.Method);
|
|
}
|
|
internal override SqlExpression VisitClientQuery(SqlClientQuery cq) {
|
|
SqlSubSelect query = (SqlSubSelect) this.VisitExpression(cq.Query);
|
|
SqlClientQuery nq = new SqlClientQuery(query);
|
|
for (int i = 0, n = cq.Arguments.Count; i < n; i++) {
|
|
nq.Arguments.Add(this.VisitExpression(cq.Arguments[i]));
|
|
}
|
|
for (int i = 0, n = cq.Parameters.Count; i < n; i++) {
|
|
nq.Parameters.Add((SqlParameter)this.VisitExpression(cq.Parameters[i]));
|
|
}
|
|
return nq;
|
|
}
|
|
internal override SqlExpression VisitJoinedCollection(SqlJoinedCollection jc) {
|
|
return new SqlJoinedCollection(jc.ClrType, jc.SqlType, this.VisitExpression(jc.Expression), this.VisitExpression(jc.Count), jc.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitClientArray(SqlClientArray scar) {
|
|
SqlExpression[] exprs = new SqlExpression[scar.Expressions.Count];
|
|
for (int i = 0, n = exprs.Length; i < n; i++) {
|
|
exprs[i] = this.VisitExpression(scar.Expressions[i]);
|
|
}
|
|
return new SqlClientArray(scar.ClrType, scar.SqlType, exprs, scar.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitTypeCase(SqlTypeCase tc) {
|
|
SqlExpression disc = VisitExpression(tc.Discriminator);
|
|
List<SqlTypeCaseWhen> whens = new List<SqlTypeCaseWhen>();
|
|
foreach(SqlTypeCaseWhen when in tc.Whens) {
|
|
whens.Add(new SqlTypeCaseWhen(VisitExpression(when.Match), VisitExpression(when.TypeBinding)));
|
|
}
|
|
return new SqlTypeCase(tc.ClrType, tc.SqlType, tc.RowType, disc, whens, tc.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitNew(SqlNew sox) {
|
|
SqlExpression[] args = new SqlExpression[sox.Args.Count];
|
|
SqlMemberAssign[] bindings = new SqlMemberAssign[sox.Members.Count];
|
|
for (int i = 0, n = args.Length; i < n; i++) {
|
|
args[i] = this.VisitExpression(sox.Args[i]);
|
|
}
|
|
for (int i = 0, n = bindings.Length; i < n; i++) {
|
|
bindings[i] = this.VisitMemberAssign(sox.Members[i]);
|
|
}
|
|
return new SqlNew(sox.MetaType, sox.SqlType, sox.Constructor, args, sox.ArgMembers, bindings, sox.SourceExpression);
|
|
}
|
|
internal override SqlNode VisitLink(SqlLink link) {
|
|
SqlExpression[] exprs = new SqlExpression[link.KeyExpressions.Count];
|
|
for (int i = 0, n = exprs.Length; i < n; i++) {
|
|
exprs[i] = this.VisitExpression(link.KeyExpressions[i]);
|
|
}
|
|
SqlLink newLink = new SqlLink(new object(), link.RowType, link.ClrType, link.SqlType, null, link.Member, exprs, null, link.SourceExpression);
|
|
this.nodeMap[link] = newLink;
|
|
// break the potential cyclic tree by visiting these after adding to the map
|
|
newLink.Expression = this.VisitExpression(link.Expression);
|
|
newLink.Expansion = this.VisitExpression(link.Expansion);
|
|
return newLink;
|
|
}
|
|
internal override SqlExpression VisitColumn(SqlColumn col) {
|
|
SqlColumn n = new SqlColumn(col.ClrType, col.SqlType, col.Name, col.MetaMember, null, col.SourceExpression);
|
|
this.nodeMap[col] = n;
|
|
n.Expression = this.VisitExpression(col.Expression);
|
|
n.Alias = (SqlAlias)this.Visit(col.Alias);
|
|
return n;
|
|
}
|
|
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
|
|
if (this.ingoreExternalRefs && !this.nodeMap.ContainsKey(cref.Column)) {
|
|
return cref;
|
|
}
|
|
return new SqlColumnRef((SqlColumn)this.Visit(cref.Column));
|
|
}
|
|
internal override SqlStatement VisitDelete(SqlDelete sd) {
|
|
return new SqlDelete((SqlSelect)this.Visit(sd.Select), sd.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitElement(SqlSubSelect elem) {
|
|
return this.VisitMultiset(elem);
|
|
}
|
|
internal override SqlExpression VisitExists(SqlSubSelect sqlExpr) {
|
|
return new SqlSubSelect(sqlExpr.NodeType, sqlExpr.ClrType, sqlExpr.SqlType, (SqlSelect)this.Visit(sqlExpr.Select));
|
|
}
|
|
internal override SqlStatement VisitInsert(SqlInsert si) {
|
|
SqlInsert n = new SqlInsert(si.Table, this.VisitExpression(si.Expression), si.SourceExpression);
|
|
n.OutputKey = si.OutputKey;
|
|
n.OutputToLocal = si.OutputToLocal;
|
|
n.Row = this.VisitRow(si.Row);
|
|
return n;
|
|
}
|
|
internal override SqlSource VisitJoin(SqlJoin join) {
|
|
SqlSource left = this.VisitSource(join.Left);
|
|
SqlSource right = this.VisitSource(join.Right);
|
|
SqlExpression cond = (SqlExpression)this.Visit(join.Condition);
|
|
return new SqlJoin(join.JoinType, left, right, cond, join.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitValue(SqlValue value) {
|
|
return value;
|
|
}
|
|
internal override SqlNode VisitMember(SqlMember m) {
|
|
return new SqlMember(m.ClrType, m.SqlType, (SqlExpression)this.Visit(m.Expression), m.Member);
|
|
}
|
|
internal override SqlMemberAssign VisitMemberAssign(SqlMemberAssign ma) {
|
|
return new SqlMemberAssign(ma.Member, (SqlExpression)this.Visit(ma.Expression));
|
|
}
|
|
internal override SqlExpression VisitMultiset(SqlSubSelect sms) {
|
|
return new SqlSubSelect(sms.NodeType, sms.ClrType, sms.SqlType, (SqlSelect)this.Visit(sms.Select));
|
|
}
|
|
internal override SqlExpression VisitParameter(SqlParameter p) {
|
|
SqlParameter n = new SqlParameter(p.ClrType, p.SqlType, p.Name, p.SourceExpression);
|
|
n.Direction = p.Direction;
|
|
return n;
|
|
}
|
|
internal override SqlRow VisitRow(SqlRow row) {
|
|
SqlRow nrow = new SqlRow(row.SourceExpression);
|
|
foreach (SqlColumn c in row.Columns) {
|
|
nrow.Columns.Add((SqlColumn)this.Visit(c));
|
|
}
|
|
return nrow;
|
|
}
|
|
internal override SqlExpression VisitScalarSubSelect(SqlSubSelect ss) {
|
|
return new SqlSubSelect(SqlNodeType.ScalarSubSelect, ss.ClrType, ss.SqlType, this.VisitSequence(ss.Select));
|
|
}
|
|
internal override SqlSelect VisitSelect(SqlSelect select) {
|
|
SqlSource from = this.VisitSource(select.From);
|
|
List<SqlExpression> gex = null;
|
|
if (select.GroupBy.Count > 0) {
|
|
gex = new List<SqlExpression>(select.GroupBy.Count);
|
|
foreach (SqlExpression sqlExpr in select.GroupBy) {
|
|
gex.Add((SqlExpression)this.Visit(sqlExpr));
|
|
}
|
|
}
|
|
SqlExpression having = (SqlExpression)this.Visit(select.Having);
|
|
List<SqlOrderExpression> lex = null;
|
|
if (select.OrderBy.Count > 0) {
|
|
lex = new List<SqlOrderExpression>(select.OrderBy.Count);
|
|
foreach (SqlOrderExpression sox in select.OrderBy) {
|
|
SqlOrderExpression nsox = new SqlOrderExpression(sox.OrderType, (SqlExpression)this.Visit(sox.Expression));
|
|
lex.Add(nsox);
|
|
}
|
|
}
|
|
SqlExpression top = (SqlExpression)this.Visit(select.Top);
|
|
SqlExpression where = (SqlExpression)this.Visit(select.Where);
|
|
SqlRow row = (SqlRow)this.Visit(select.Row);
|
|
SqlExpression selection = this.VisitExpression(select.Selection);
|
|
|
|
SqlSelect n = new SqlSelect(selection, from, select.SourceExpression);
|
|
if (gex != null)
|
|
n.GroupBy.AddRange(gex);
|
|
n.Having = having;
|
|
if (lex != null)
|
|
n.OrderBy.AddRange(lex);
|
|
n.OrderingType = select.OrderingType;
|
|
n.Row = row;
|
|
n.Top = top;
|
|
n.IsDistinct = select.IsDistinct;
|
|
n.IsPercent = select.IsPercent;
|
|
n.Where = where;
|
|
n.DoNotOutput = select.DoNotOutput;
|
|
return n;
|
|
}
|
|
internal override SqlTable VisitTable(SqlTable tab) {
|
|
SqlTable nt = new SqlTable(tab.MetaTable, tab.RowType, tab.SqlRowType, tab.SourceExpression);
|
|
this.nodeMap[tab] = nt;
|
|
foreach (SqlColumn c in tab.Columns) {
|
|
nt.Columns.Add((SqlColumn)this.Visit(c));
|
|
}
|
|
return nt;
|
|
}
|
|
internal override SqlUserQuery VisitUserQuery(SqlUserQuery suq) {
|
|
List<SqlExpression> args = new List<SqlExpression>(suq.Arguments.Count);
|
|
foreach (SqlExpression expr in suq.Arguments) {
|
|
args.Add(this.VisitExpression(expr));
|
|
}
|
|
SqlExpression projection = this.VisitExpression(suq.Projection);
|
|
SqlUserQuery n = new SqlUserQuery(suq.QueryText, projection, args, suq.SourceExpression);
|
|
this.nodeMap[suq] = n;
|
|
|
|
foreach (SqlUserColumn suc in suq.Columns) {
|
|
SqlUserColumn dupSuc = new SqlUserColumn(suc.ClrType, suc.SqlType, suc.Query, suc.Name, suc.IsRequired, suc.SourceExpression);
|
|
this.nodeMap[suc] = dupSuc;
|
|
n.Columns.Add(dupSuc);
|
|
}
|
|
|
|
return n;
|
|
}
|
|
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc) {
|
|
List<SqlExpression> args = new List<SqlExpression>(spc.Arguments.Count);
|
|
foreach (SqlExpression expr in spc.Arguments) {
|
|
args.Add(this.VisitExpression(expr));
|
|
}
|
|
SqlExpression projection = this.VisitExpression(spc.Projection);
|
|
SqlStoredProcedureCall n = new SqlStoredProcedureCall(spc.Function, projection, args, spc.SourceExpression);
|
|
this.nodeMap[spc] = n;
|
|
foreach (SqlUserColumn suc in spc.Columns) {
|
|
n.Columns.Add((SqlUserColumn)this.Visit(suc));
|
|
}
|
|
return n;
|
|
}
|
|
internal override SqlExpression VisitUserColumn(SqlUserColumn suc) {
|
|
if (this.ingoreExternalRefs && !this.nodeMap.ContainsKey(suc)) {
|
|
return suc;
|
|
}
|
|
return new SqlUserColumn(suc.ClrType, suc.SqlType, suc.Query, suc.Name, suc.IsRequired, suc.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitUserRow(SqlUserRow row) {
|
|
return new SqlUserRow(row.RowType, row.SqlType, (SqlUserQuery)this.Visit(row.Query), row.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitTreat(SqlUnary t) {
|
|
return new SqlUnary(SqlNodeType.Treat, t.ClrType, t.SqlType, (SqlExpression)this.Visit(t.Operand), t.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) {
|
|
return new SqlUnary(uo.NodeType, uo.ClrType, uo.SqlType, (SqlExpression)this.Visit(uo.Operand), uo.Method, uo.SourceExpression);
|
|
}
|
|
internal override SqlStatement VisitUpdate(SqlUpdate su) {
|
|
SqlSelect ss = (SqlSelect)this.Visit(su.Select);
|
|
List<SqlAssign> assignments = new List<SqlAssign>(su.Assignments.Count);
|
|
foreach (SqlAssign sa in su.Assignments) {
|
|
assignments.Add((SqlAssign)this.Visit(sa));
|
|
}
|
|
return new SqlUpdate(ss, assignments, su.SourceExpression);
|
|
}
|
|
internal override SqlStatement VisitAssign(SqlAssign sa) {
|
|
return new SqlAssign(this.VisitExpression(sa.LValue), this.VisitExpression(sa.RValue), sa.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) {
|
|
SqlExpression @else = this.VisitExpression(c.Else);
|
|
SqlWhen[] whens = new SqlWhen[c.Whens.Count];
|
|
for (int i = 0, n = whens.Length; i < n; i++) {
|
|
SqlWhen when = c.Whens[i];
|
|
whens[i] = new SqlWhen(this.VisitExpression(when.Match), this.VisitExpression(when.Value));
|
|
}
|
|
return new SqlSearchedCase(c.ClrType, whens, @else, c.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitClientCase(SqlClientCase c) {
|
|
SqlExpression expr = this.VisitExpression(c.Expression);
|
|
SqlClientWhen[] whens = new SqlClientWhen[c.Whens.Count];
|
|
for (int i = 0, n = whens.Length; i < n; i++) {
|
|
SqlClientWhen when = c.Whens[i];
|
|
whens[i] = new SqlClientWhen(this.VisitExpression(when.Match), this.VisitExpression(when.Value));
|
|
}
|
|
return new SqlClientCase(c.ClrType, expr, whens, c.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitSimpleCase(SqlSimpleCase c) {
|
|
SqlExpression expr = this.VisitExpression(c.Expression);
|
|
SqlWhen[] whens = new SqlWhen[c.Whens.Count];
|
|
for (int i = 0, n = whens.Length; i < n; i++) {
|
|
SqlWhen when = c.Whens[i];
|
|
whens[i] = new SqlWhen(this.VisitExpression(when.Match), this.VisitExpression(when.Value));
|
|
}
|
|
return new SqlSimpleCase(c.ClrType, expr, whens, c.SourceExpression);
|
|
}
|
|
internal override SqlNode VisitUnion(SqlUnion su) {
|
|
return new SqlUnion(this.Visit(su.Left), this.Visit(su.Right), su.All);
|
|
}
|
|
internal override SqlExpression VisitExprSet(SqlExprSet xs) {
|
|
SqlExpression[] exprs = new SqlExpression[xs.Expressions.Count];
|
|
for (int i = 0, n = exprs.Length; i < n; i++) {
|
|
exprs[i] = this.VisitExpression(xs.Expressions[i]);
|
|
}
|
|
return new SqlExprSet(xs.ClrType, exprs, xs.SourceExpression);
|
|
}
|
|
internal override SqlBlock VisitBlock(SqlBlock block) {
|
|
SqlBlock nb = new SqlBlock(block.SourceExpression);
|
|
foreach (SqlStatement stmt in block.Statements) {
|
|
nb.Statements.Add((SqlStatement)this.Visit(stmt));
|
|
}
|
|
return nb;
|
|
}
|
|
internal override SqlExpression VisitVariable(SqlVariable v) {
|
|
return v;
|
|
}
|
|
internal override SqlExpression VisitOptionalValue(SqlOptionalValue sov) {
|
|
SqlExpression hasValue = this.VisitExpression(sov.HasValue);
|
|
SqlExpression value = this.VisitExpression(sov.Value);
|
|
return new SqlOptionalValue(hasValue, value);
|
|
}
|
|
internal override SqlExpression VisitBetween(SqlBetween between) {
|
|
SqlBetween nbet = new SqlBetween(
|
|
between.ClrType,
|
|
between.SqlType,
|
|
this.VisitExpression(between.Expression),
|
|
this.VisitExpression(between.Start),
|
|
this.VisitExpression(between.End),
|
|
between.SourceExpression
|
|
);
|
|
return nbet;
|
|
}
|
|
internal override SqlExpression VisitIn(SqlIn sin) {
|
|
SqlIn nin = new SqlIn(sin.ClrType, sin.SqlType, this.VisitExpression(sin.Expression), sin.Values, sin.SourceExpression);
|
|
for (int i = 0, n = nin.Values.Count; i < n; i++) {
|
|
nin.Values[i] = this.VisitExpression(nin.Values[i]);
|
|
}
|
|
return nin;
|
|
}
|
|
internal override SqlExpression VisitLike(SqlLike like) {
|
|
return new SqlLike(
|
|
like.ClrType, like.SqlType,
|
|
this.VisitExpression(like.Expression),
|
|
this.VisitExpression(like.Pattern),
|
|
this.VisitExpression(like.Escape),
|
|
like.SourceExpression
|
|
);
|
|
}
|
|
internal override SqlExpression VisitFunctionCall(SqlFunctionCall fc) {
|
|
SqlExpression[] args = new SqlExpression[fc.Arguments.Count];
|
|
for (int i = 0, n = fc.Arguments.Count; i < n; i++) {
|
|
args[i] = this.VisitExpression(fc.Arguments[i]);
|
|
}
|
|
return new SqlFunctionCall(fc.ClrType, fc.SqlType, fc.Name, args, fc.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitTableValuedFunctionCall(SqlTableValuedFunctionCall fc) {
|
|
SqlExpression[] args = new SqlExpression[fc.Arguments.Count];
|
|
for (int i = 0, n = fc.Arguments.Count; i < n; i++) {
|
|
args[i] = this.VisitExpression(fc.Arguments[i]);
|
|
}
|
|
SqlTableValuedFunctionCall nfc = new SqlTableValuedFunctionCall(fc.RowType, fc.ClrType, fc.SqlType, fc.Name, args, fc.SourceExpression);
|
|
this.nodeMap[fc] = nfc;
|
|
foreach (SqlColumn c in fc.Columns) {
|
|
nfc.Columns.Add((SqlColumn)this.Visit(c));
|
|
}
|
|
return nfc;
|
|
}
|
|
internal override SqlExpression VisitMethodCall(SqlMethodCall mc) {
|
|
SqlExpression[] args = new SqlExpression[mc.Arguments.Count];
|
|
for (int i = 0, n = mc.Arguments.Count; i < n; i++) {
|
|
args[i] = this.VisitExpression(mc.Arguments[i]);
|
|
}
|
|
return new SqlMethodCall(mc.ClrType, mc.SqlType, mc.Method, this.VisitExpression(mc.Object), args, mc.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitSharedExpression(SqlSharedExpression sub) {
|
|
SqlSharedExpression n = new SqlSharedExpression(sub.Expression);
|
|
this.nodeMap[sub] = n;
|
|
n.Expression = this.VisitExpression(sub.Expression);
|
|
return n;
|
|
}
|
|
internal override SqlExpression VisitSharedExpressionRef(SqlSharedExpressionRef sref) {
|
|
if (this.ingoreExternalRefs && !this.nodeMap.ContainsKey(sref.SharedExpression)) {
|
|
return sref;
|
|
}
|
|
return new SqlSharedExpressionRef((SqlSharedExpression)this.Visit(sref.SharedExpression));
|
|
}
|
|
internal override SqlExpression VisitSimpleExpression(SqlSimpleExpression simple) {
|
|
SqlSimpleExpression n = new SqlSimpleExpression(this.VisitExpression(simple.Expression));
|
|
return n;
|
|
}
|
|
internal override SqlExpression VisitGrouping(SqlGrouping g) {
|
|
SqlGrouping n = new SqlGrouping(g.ClrType, g.SqlType,
|
|
this.VisitExpression(g.Key), this.VisitExpression(g.Group), g.SourceExpression
|
|
);
|
|
return n;
|
|
}
|
|
internal override SqlExpression VisitDiscriminatedType(SqlDiscriminatedType dt) {
|
|
return new SqlDiscriminatedType(dt.SqlType, this.VisitExpression(dt.Discriminator), dt.TargetType, dt.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitLift(SqlLift lift) {
|
|
return new SqlLift(lift.ClrType, this.VisitExpression(lift.Expression), lift.SourceExpression);
|
|
}
|
|
internal override SqlExpression VisitDiscriminatorOf(SqlDiscriminatorOf dof) {
|
|
return new SqlDiscriminatorOf(this.VisitExpression(dof.Object), dof.ClrType, dof.SqlType, dof.SourceExpression);
|
|
}
|
|
internal override SqlNode VisitIncludeScope(SqlIncludeScope scope) {
|
|
return new SqlIncludeScope(this.Visit(scope.Child), scope.SourceExpression);
|
|
}
|
|
}
|
|
}
|
|
}
|