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
372 lines
14 KiB
C#
372 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq.Expressions;
|
|
using System.Data.Linq;
|
|
|
|
namespace System.Data.Linq.SqlClient {
|
|
|
|
// convert multiset & element expressions into separate queries
|
|
|
|
internal class SqlMultiplexer {
|
|
Visitor visitor;
|
|
|
|
internal enum Options {
|
|
None,
|
|
EnableBigJoin
|
|
}
|
|
|
|
internal SqlMultiplexer(Options options, IEnumerable<System.Data.Linq.SqlClient.SqlParameter> parentParameters, SqlFactory sqlFactory) {
|
|
this.visitor = new Visitor(options, parentParameters, sqlFactory);
|
|
}
|
|
|
|
internal SqlNode Multiplex(SqlNode node) {
|
|
return this.visitor.Visit(node);
|
|
}
|
|
|
|
class Visitor : SqlVisitor {
|
|
Options options;
|
|
SqlFactory sql;
|
|
SqlSelect outerSelect;
|
|
bool hasBigJoin;
|
|
bool canJoin;
|
|
bool isTopLevel;
|
|
IEnumerable<System.Data.Linq.SqlClient.SqlParameter> parentParameters;
|
|
|
|
internal Visitor(Options options, IEnumerable<System.Data.Linq.SqlClient.SqlParameter> parentParameters, SqlFactory sqlFactory) {
|
|
this.options = options;
|
|
this.sql = sqlFactory;
|
|
this.canJoin = true;
|
|
this.isTopLevel = true;
|
|
this.parentParameters = parentParameters;
|
|
}
|
|
|
|
internal override SqlExpression VisitMultiset(SqlSubSelect sms) {
|
|
// allow one big-join per query?
|
|
if ((this.options & Options.EnableBigJoin) != 0 &&
|
|
!this.hasBigJoin && this.canJoin && this.isTopLevel && this.outerSelect != null
|
|
&& !MultisetChecker.HasMultiset(sms.Select.Selection)
|
|
&& BigJoinChecker.CanBigJoin(sms.Select)) {
|
|
|
|
sms.Select = this.VisitSelect(sms.Select);
|
|
|
|
SqlAlias alias = new SqlAlias(sms.Select);
|
|
SqlJoin join = new SqlJoin(SqlJoinType.OuterApply, this.outerSelect.From, alias, null, sms.SourceExpression);
|
|
this.outerSelect.From = join;
|
|
this.outerSelect.OrderingType = SqlOrderingType.Always;
|
|
|
|
// make joined expression
|
|
SqlExpression expr = (SqlExpression)SqlDuplicator.Copy(sms.Select.Selection);
|
|
|
|
// make count expression
|
|
SqlSelect copySelect = (SqlSelect)SqlDuplicator.Copy(sms.Select);
|
|
SqlAlias copyAlias = new SqlAlias(copySelect);
|
|
SqlSelect countSelect = new SqlSelect(sql.Unary(SqlNodeType.Count, null, sms.SourceExpression), copyAlias, sms.SourceExpression);
|
|
countSelect.OrderingType = SqlOrderingType.Never;
|
|
SqlExpression count = sql.SubSelect(SqlNodeType.ScalarSubSelect, countSelect);
|
|
|
|
// make joined collection
|
|
SqlJoinedCollection jc = new SqlJoinedCollection(sms.ClrType, sms.SqlType, expr, count, sms.SourceExpression);
|
|
this.hasBigJoin = true;
|
|
return jc;
|
|
}
|
|
else {
|
|
return QueryExtractor.Extract(sms, this.parentParameters);
|
|
}
|
|
}
|
|
|
|
internal override SqlExpression VisitElement(SqlSubSelect elem) {
|
|
return QueryExtractor.Extract(elem, this.parentParameters);
|
|
}
|
|
|
|
internal override SqlExpression VisitScalarSubSelect(SqlSubSelect ss) {
|
|
bool saveIsTopLevel = this.isTopLevel;
|
|
this.isTopLevel = false;
|
|
bool saveCanJoin = this.canJoin;
|
|
this.canJoin = false;
|
|
try {
|
|
return base.VisitScalarSubSelect(ss);
|
|
}
|
|
finally {
|
|
this.isTopLevel = saveIsTopLevel;
|
|
this.canJoin = saveCanJoin;
|
|
}
|
|
}
|
|
|
|
internal override SqlExpression VisitExists(SqlSubSelect ss) {
|
|
bool saveIsTopLevel = this.isTopLevel;
|
|
this.isTopLevel = false;
|
|
bool saveCanJoin = this.canJoin;
|
|
this.canJoin = false;
|
|
try {
|
|
return base.VisitExists(ss);
|
|
}
|
|
finally {
|
|
this.isTopLevel = saveIsTopLevel;
|
|
this.canJoin = saveCanJoin;
|
|
}
|
|
}
|
|
|
|
internal override SqlSelect VisitSelect(SqlSelect select) {
|
|
SqlSelect saveSelect = this.outerSelect;
|
|
this.outerSelect = select;
|
|
|
|
// big-joins may need to lift PK's out for default ordering, so don't allow big-join if we see these
|
|
this.canJoin &= select.GroupBy.Count == 0 && select.Top == null && !select.IsDistinct;
|
|
|
|
bool saveIsTopLevel = this.isTopLevel;
|
|
this.isTopLevel = false;
|
|
|
|
select = this.VisitSelectCore(select);
|
|
|
|
this.isTopLevel = saveIsTopLevel;
|
|
select.Selection = this.VisitExpression(select.Selection);
|
|
|
|
this.isTopLevel = saveIsTopLevel;
|
|
this.outerSelect = saveSelect;
|
|
|
|
if (select.IsDistinct && HierarchyChecker.HasHierarchy(select.Selection)) {
|
|
// distinct across heirarchy is a NO-OP
|
|
select.IsDistinct = false;
|
|
}
|
|
return select;
|
|
}
|
|
|
|
internal override SqlNode VisitUnion(SqlUnion su) {
|
|
this.canJoin = false;
|
|
return base.VisitUnion(su);
|
|
}
|
|
|
|
internal override SqlExpression VisitClientCase(SqlClientCase c) {
|
|
bool saveCanJoin = this.canJoin;
|
|
this.canJoin = false;
|
|
try {
|
|
return base.VisitClientCase(c);
|
|
}
|
|
finally {
|
|
this.canJoin = saveCanJoin;
|
|
}
|
|
}
|
|
|
|
internal override SqlExpression VisitSimpleCase(SqlSimpleCase c) {
|
|
bool saveCanJoin = this.canJoin;
|
|
this.canJoin = false;
|
|
try {
|
|
return base.VisitSimpleCase(c);
|
|
}
|
|
finally {
|
|
this.canJoin = saveCanJoin;
|
|
}
|
|
}
|
|
|
|
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) {
|
|
bool saveCanJoin = this.canJoin;
|
|
this.canJoin = false;
|
|
try {
|
|
return base.VisitSearchedCase(c);
|
|
}
|
|
finally {
|
|
this.canJoin = saveCanJoin;
|
|
}
|
|
}
|
|
|
|
internal override SqlExpression VisitTypeCase(SqlTypeCase tc) {
|
|
bool saveCanJoin = this.canJoin;
|
|
this.canJoin = false;
|
|
try {
|
|
return base.VisitTypeCase(tc);
|
|
}
|
|
finally {
|
|
this.canJoin = saveCanJoin;
|
|
}
|
|
}
|
|
|
|
internal override SqlExpression VisitOptionalValue(SqlOptionalValue sov) {
|
|
bool saveCanJoin = this.canJoin;
|
|
this.canJoin = false;
|
|
try {
|
|
return base.VisitOptionalValue(sov);
|
|
}
|
|
finally {
|
|
this.canJoin = saveCanJoin;
|
|
}
|
|
}
|
|
|
|
internal override SqlUserQuery VisitUserQuery(SqlUserQuery suq) {
|
|
this.canJoin = false;
|
|
return base.VisitUserQuery(suq);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class QueryExtractor {
|
|
|
|
internal static SqlClientQuery Extract(SqlSubSelect subquery, IEnumerable<System.Data.Linq.SqlClient.SqlParameter> parentParameters) {
|
|
SqlClientQuery cq = new SqlClientQuery(subquery);
|
|
if (parentParameters != null) {
|
|
cq.Parameters.AddRange(parentParameters);
|
|
}
|
|
Visitor v = new Visitor(cq.Arguments, cq.Parameters);
|
|
cq.Query = (SqlSubSelect)v.Visit(subquery);
|
|
return cq;
|
|
}
|
|
|
|
class Visitor : SqlDuplicator.DuplicatingVisitor {
|
|
List<SqlExpression> externals;
|
|
List<SqlParameter> parameters;
|
|
|
|
internal Visitor(List<SqlExpression> externals, List<SqlParameter> parameters)
|
|
: base(true) {
|
|
this.externals = externals;
|
|
this.parameters = parameters;
|
|
}
|
|
|
|
internal override SqlExpression VisitColumnRef(SqlColumnRef cref) {
|
|
SqlExpression result = base.VisitColumnRef(cref);
|
|
if (result == cref) { // must be external
|
|
return ExtractParameter(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
internal override SqlExpression VisitUserColumn(SqlUserColumn suc) {
|
|
SqlExpression result = base.VisitUserColumn(suc);
|
|
if (result == suc) { // must be external
|
|
return ExtractParameter(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private SqlExpression ExtractParameter(SqlExpression expr) {
|
|
Type clrType = expr.ClrType;
|
|
if (expr.ClrType.IsValueType && !TypeSystem.IsNullableType(expr.ClrType)) {
|
|
clrType = typeof(Nullable<>).MakeGenericType(expr.ClrType);
|
|
}
|
|
this.externals.Add(expr);
|
|
SqlParameter sp = new SqlParameter(clrType, expr.SqlType, "@x" + (this.parameters.Count + 1), expr.SourceExpression);
|
|
this.parameters.Add(sp);
|
|
return sp;
|
|
}
|
|
|
|
internal override SqlNode VisitLink(SqlLink link) {
|
|
// Don't visit the Expression/Expansion for this link.
|
|
// Any additional external refs in these expressions
|
|
// should be ignored
|
|
SqlExpression[] exprs = new SqlExpression[link.KeyExpressions.Count];
|
|
for (int i = 0, n = exprs.Length; i < n; i++) {
|
|
exprs[i] = this.VisitExpression(link.KeyExpressions[i]);
|
|
}
|
|
return new SqlLink(new object(), link.RowType, link.ClrType, link.SqlType, null, link.Member, exprs, null, link.SourceExpression);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class HierarchyChecker {
|
|
internal static bool HasHierarchy(SqlExpression expr) {
|
|
Visitor v = new Visitor();
|
|
v.Visit(expr);
|
|
return v.foundHierarchy;
|
|
}
|
|
|
|
class Visitor : SqlVisitor {
|
|
internal bool foundHierarchy;
|
|
|
|
internal override SqlExpression VisitMultiset(SqlSubSelect sms) {
|
|
this.foundHierarchy = true;
|
|
return sms;
|
|
}
|
|
|
|
internal override SqlExpression VisitElement(SqlSubSelect elem) {
|
|
this.foundHierarchy = true;
|
|
return elem;
|
|
}
|
|
|
|
internal override SqlExpression VisitClientQuery(SqlClientQuery cq) {
|
|
this.foundHierarchy = true;
|
|
return cq;
|
|
}
|
|
|
|
internal override SqlExpression VisitExists(SqlSubSelect ss) {
|
|
return ss;
|
|
}
|
|
|
|
internal override SqlExpression VisitScalarSubSelect(SqlSubSelect ss) {
|
|
return ss;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class MultisetChecker {
|
|
internal static bool HasMultiset(SqlExpression expr) {
|
|
Visitor v = new Visitor();
|
|
v.Visit(expr);
|
|
return v.foundMultiset;
|
|
}
|
|
|
|
class Visitor : SqlVisitor {
|
|
internal bool foundMultiset;
|
|
|
|
internal override SqlExpression VisitMultiset(SqlSubSelect sms) {
|
|
this.foundMultiset = true;
|
|
return sms;
|
|
}
|
|
|
|
internal override SqlExpression VisitElement(SqlSubSelect elem) {
|
|
return elem;
|
|
}
|
|
|
|
internal override SqlExpression VisitClientQuery(SqlClientQuery cq) {
|
|
return cq;
|
|
}
|
|
|
|
internal override SqlExpression VisitExists(SqlSubSelect ss) {
|
|
return ss;
|
|
}
|
|
|
|
internal override SqlExpression VisitScalarSubSelect(SqlSubSelect ss) {
|
|
return ss;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class BigJoinChecker {
|
|
internal static bool CanBigJoin(SqlSelect select) {
|
|
Visitor v = new Visitor();
|
|
v.Visit(select);
|
|
return v.canBigJoin;
|
|
}
|
|
|
|
class Visitor : SqlVisitor {
|
|
internal bool canBigJoin = true;
|
|
|
|
internal override SqlExpression VisitMultiset(SqlSubSelect sms) {
|
|
return sms;
|
|
}
|
|
|
|
internal override SqlExpression VisitElement(SqlSubSelect elem) {
|
|
return elem;
|
|
}
|
|
|
|
internal override SqlExpression VisitClientQuery(SqlClientQuery cq) {
|
|
return cq;
|
|
}
|
|
|
|
internal override SqlExpression VisitExists(SqlSubSelect ss) {
|
|
return ss;
|
|
}
|
|
|
|
internal override SqlExpression VisitScalarSubSelect(SqlSubSelect ss) {
|
|
return ss;
|
|
}
|
|
|
|
internal override SqlSelect VisitSelect(SqlSelect select) {
|
|
// big-joins may need to lift PK's out for default ordering, so don't allow big-join if we see these
|
|
this.canBigJoin &= select.GroupBy.Count == 0 && select.Top == null && !select.IsDistinct;
|
|
if (!this.canBigJoin) {
|
|
return select;
|
|
}
|
|
return base.VisitSelect(select);
|
|
}
|
|
}
|
|
}
|
|
}
|