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

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