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

293 lines
12 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace System.Data.Linq.SqlClient {
using System.Data.Linq.Mapping;
using System.Data.Linq.Provider;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
// moves order-by clauses from sub-queries to outer-most or top selects
// removes ordering in correlated sub-queries
internal class SqlReorderer {
TypeSystemProvider typeProvider;
SqlFactory sql;
internal SqlReorderer(TypeSystemProvider typeProvider, SqlFactory sqlFactory) {
this.typeProvider = typeProvider;
this.sql = sqlFactory;
}
internal SqlNode Reorder(SqlNode node) {
return new Visitor(this.typeProvider, this.sql).Visit(node);
}
class Visitor : SqlVisitor {
TypeSystemProvider typeProvider;
bool topSelect = true;
bool addPrimaryKeys;
List<SqlOrderExpression> orders;
List<SqlOrderExpression> rowNumberOrders;
SqlSelect currentSelect;
SqlFactory sql;
SqlAggregateChecker aggregateChecker;
internal Visitor(TypeSystemProvider typeProvider, SqlFactory sqlFactory) {
this.orders = new List<SqlOrderExpression>();
this.typeProvider = typeProvider;
this.sql = sqlFactory;
this.aggregateChecker = new SqlAggregateChecker();
}
internal override SqlExpression VisitSubSelect(SqlSubSelect ss) {
List<SqlOrderExpression> save = this.orders;
this.orders = new List<SqlOrderExpression>();
base.VisitSubSelect(ss);
this.orders = save;
return ss;
}
private void PrependOrderExpressions(IEnumerable<SqlOrderExpression> exprs) {
if (exprs != null) {
this.Orders.InsertRange(0, exprs);
}
}
private List<SqlOrderExpression> Orders {
get {
if (this.orders == null) {
this.orders = new List<SqlOrderExpression>();
}
return this.orders;
}
}
internal override SqlSource VisitJoin(SqlJoin join) {
this.Visit(join.Left);
List<SqlOrderExpression> leftOrders = this.orders;
this.orders = null;
this.Visit(join.Right);
this.PrependOrderExpressions(leftOrders);
return join;
}
internal override SqlNode VisitUnion(SqlUnion su) {
// ordering does not carry through a union
this.orders = null;
su.Left = this.Visit(su.Left);
this.orders = null;
su.Right = this.Visit(su.Right);
this.orders = null;
return su;
}
internal override SqlAlias VisitAlias(SqlAlias a) {
SqlTable tab = a.Node as SqlTable;
SqlTableValuedFunctionCall tvf = a.Node as SqlTableValuedFunctionCall;
if (this.addPrimaryKeys && (tab != null || tvf != null)) {
List<SqlOrderExpression> list = new List<SqlOrderExpression>();
bool isTable = tab != null;
MetaType rowType = isTable ? tab.RowType : tvf.RowType;
foreach (MetaDataMember mm in rowType.IdentityMembers) {
string name = mm.MappedName;
SqlColumn col;
Expression sourceExpression;
List<SqlColumn> columns;
if (isTable) {
col = tab.Find(name);
sourceExpression = tab.SourceExpression;
columns = tab.Columns;
}
else {
col = tvf.Find(name);
sourceExpression = tvf.SourceExpression;
columns = tvf.Columns;
}
if (col == null) {
col = new SqlColumn(mm.MemberAccessor.Type, typeProvider.From(mm.MemberAccessor.Type), name, mm, null, sourceExpression);
col.Alias = a;
columns.Add(col);
}
list.Add(new SqlOrderExpression(SqlOrderType.Ascending, new SqlColumnRef(col)));
}
this.PrependOrderExpressions(list);
return a;
}
else {
return base.VisitAlias(a);
}
}
internal override SqlSelect VisitSelect(SqlSelect select) {
bool saveTop = this.topSelect;
bool savePK = this.addPrimaryKeys;
SqlSelect saveSelect = this.currentSelect;
this.currentSelect = select;
if (select.OrderingType == SqlOrderingType.Always) {
this.addPrimaryKeys = true;
}
this.topSelect = false;
// can't forward ordering information through a group-by
if (select.GroupBy.Count > 0) {
this.Visit(select.From);
this.orders = null;
}
else {
this.Visit(select.From);
}
if (select.OrderBy.Count > 0) {
this.PrependOrderExpressions(select.OrderBy);
}
List<SqlOrderExpression> save = this.orders;
this.orders = null;
this.rowNumberOrders = save; // lest orders be null when we need info
/* do all the lower level stuff */
select.Where = this.VisitExpression(select.Where);
for (int i = 0, n = select.GroupBy.Count; i < n; i++) {
select.GroupBy[i] = this.VisitExpression(select.GroupBy[i]);
}
select.Having = this.VisitExpression(select.Having);
for (int i = 0, n = select.OrderBy.Count; i < n; i++) {
select.OrderBy[i].Expression = this.VisitExpression(select.OrderBy[i].Expression);
}
select.Top = this.VisitExpression(select.Top);
select.Selection = this.VisitExpression(select.Selection);
select.Row = (SqlRow)this.Visit(select.Row);
this.topSelect = saveTop;
this.addPrimaryKeys = savePK;
this.orders = save;
// all ordering is blocked for this layer and above
if (select.OrderingType == SqlOrderingType.Blocked) {
this.orders = null;
}
// rebuild orderby expressions, provided this select doesn't contain a SqlRowNumber
// otherwise, replace the orderby with a reference to that column
select.OrderBy.Clear();
var rowNumberChecker = new SqlRowNumberChecker();
if (rowNumberChecker.HasRowNumber(select) && rowNumberChecker.RowNumberColumn != null) {
select.Row.Columns.Remove(rowNumberChecker.RowNumberColumn);
this.PushDown(rowNumberChecker.RowNumberColumn);
this.Orders.Add(new SqlOrderExpression(SqlOrderType.Ascending, new SqlColumnRef(rowNumberChecker.RowNumberColumn)));
}
if ((this.topSelect || select.Top != null) && select.OrderingType != SqlOrderingType.Never && this.orders != null) {
this.orders = new HashSet<SqlOrderExpression>(this.orders).ToList();
SqlDuplicator dup = new SqlDuplicator(true);
foreach (SqlOrderExpression sox in this.orders) {
select.OrderBy.Add(new SqlOrderExpression(sox.OrderType, (SqlExpression)dup.Duplicate(sox.Expression)));
}
}
this.currentSelect = saveSelect;
return select;
}
internal override SqlRowNumber VisitRowNumber(SqlRowNumber rowNumber) {
if (rowNumber.OrderBy.Count > 0) return rowNumber;
SqlDuplicator dup = new SqlDuplicator(true);
List<SqlOrderExpression> orderBy = new List<SqlOrderExpression>();
List<SqlOrderExpression> existingOrders = new List<SqlOrderExpression>();
if (this.rowNumberOrders != null && this.rowNumberOrders.Count != 0) {
existingOrders = new List<SqlOrderExpression>(this.rowNumberOrders);
}
else if (this.orders != null) {
existingOrders = new List<SqlOrderExpression>(this.orders);
}
foreach (SqlOrderExpression expr in existingOrders) {
if (!expr.Expression.IsConstantColumn) {
orderBy.Add(expr);
if (this.rowNumberOrders != null) {
this.rowNumberOrders.Remove(expr);
}
if (this.orders != null) {
this.orders.Remove(expr);
}
}
}
rowNumber.OrderBy.Clear();
if (orderBy.Count == 0) {
List<SqlColumn> columns = SqlGatherColumnsProduced.GatherColumns(this.currentSelect.From);
foreach (SqlColumn col in columns) {
if (col.Expression.SqlType.IsOrderable) {
orderBy.Add(new SqlOrderExpression(SqlOrderType.Ascending, new SqlColumnRef(col)));
}
}
if (orderBy.Count == 0) {
// insert simple column
SqlColumn col =
new SqlColumn(
"rowNumberOrder",
sql.Value(typeof(int), this.typeProvider.From(typeof(int)), 1, false, rowNumber.SourceExpression)
);
this.PushDown(col);
orderBy.Add(new SqlOrderExpression(SqlOrderType.Ascending, new SqlColumnRef(col)));
}
}
foreach (SqlOrderExpression sox in orderBy) {
rowNumber.OrderBy.Add(new SqlOrderExpression(sox.OrderType, (SqlExpression)dup.Duplicate(sox.Expression)));
}
return rowNumber;
}
private void PushDown(SqlColumn column) {
SqlSelect select = new SqlSelect(new SqlNop(column.ClrType, column.SqlType, column.SourceExpression), this.currentSelect.From, this.currentSelect.SourceExpression);
this.currentSelect.From = new SqlAlias(select);
select.Row.Columns.Add(column);
}
}
internal class SqlGatherColumnsProduced {
static internal List<SqlColumn> GatherColumns(SqlSource source) {
List<SqlColumn> columns = new List<SqlColumn>();
new Visitor(columns).Visit(source);
return columns;
}
class Visitor : SqlVisitor {
List<SqlColumn> columns;
internal Visitor(List<SqlColumn> columns) {
this.columns = columns;
}
internal override SqlSelect VisitSelect(SqlSelect select) {
foreach (SqlColumn c in select.Row.Columns) {
this.columns.Add(c);
}
return select;
}
internal override SqlNode VisitUnion(SqlUnion su) {
return su;
}
}
}
}
}