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
304 lines
13 KiB
C#
304 lines
13 KiB
C#
//---------------------------------------------------------------------
|
|
// <copyright file="EntityDataSourceQueryBuilder.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//
|
|
// @owner [....]
|
|
// @backupOwner [....]
|
|
//---------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls
|
|
{
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Data.Common;
|
|
using System.Data.Metadata.Edm;
|
|
using System.Data.Objects;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
|
|
internal abstract class EntityDataSourceQueryBuilder<T>
|
|
{
|
|
private readonly DataSourceSelectArguments _arguments;
|
|
private readonly string _commandText;
|
|
private readonly ObjectParameter[] _commandParameters;
|
|
private readonly string _whereExpression;
|
|
private readonly ObjectParameter[] _whereParameters;
|
|
private readonly string _entitySetQueryExpression;
|
|
private readonly OrderByBuilder _orderByBuilder;
|
|
private string _includePaths;
|
|
private TypeUsage _resultType;
|
|
private Nullable<int> _count;
|
|
|
|
protected EntityDataSourceQueryBuilder(DataSourceSelectArguments arguments,
|
|
string commandText, ObjectParameter[] commandParameters,
|
|
string whereExpression, ObjectParameter[] whereParameters, string entitySetQueryExpression,
|
|
string selectExpression, string groupByExpression, ObjectParameter[] selectParameters,
|
|
OrderByBuilder orderByBuilder,
|
|
string includePaths)
|
|
{
|
|
_arguments = arguments;
|
|
_commandText = commandText;
|
|
_commandParameters = commandParameters;
|
|
_whereExpression = whereExpression;
|
|
_whereParameters = whereParameters;
|
|
_entitySetQueryExpression = entitySetQueryExpression;
|
|
_orderByBuilder = orderByBuilder;
|
|
_includePaths = includePaths;
|
|
}
|
|
|
|
internal delegate EntityDataSourceQueryBuilder<T> Creator(DataSourceSelectArguments arguments,
|
|
string commandText, ObjectParameter[] commandParameters,
|
|
string whereExpression, ObjectParameter[] whereParameters, string entitySetQueryExpression,
|
|
string selectExpression, string groupByExpression, ObjectParameter[] selectParameters,
|
|
OrderByBuilder orderByBuilder,
|
|
string includePaths);
|
|
|
|
internal TypeUsage ResultType
|
|
{
|
|
get
|
|
{
|
|
Debug.Assert(_resultType != null, "ResultType is only valid after Build()");
|
|
return _resultType;
|
|
}
|
|
}
|
|
internal int TotalCount
|
|
{
|
|
get
|
|
{
|
|
Debug.Assert(_count.HasValue, "Count is not valid until after Build. And only then if computeCount is true");
|
|
return _count.Value;
|
|
}
|
|
}
|
|
internal IEnumerable Execute(ObjectQuery<T> queryT)
|
|
{
|
|
return (IEnumerable)(((IListSource)(queryT)).GetList());
|
|
}
|
|
|
|
internal ObjectQuery<T> BuildBasicQuery(ObjectContext context, bool computeCount)
|
|
{
|
|
ObjectQuery<T> queryT = QueryBuilderUtils.ConstructQuery<T>(context, _entitySetQueryExpression, _commandText, _commandParameters);
|
|
queryT = ApplyWhere(queryT);
|
|
queryT = ApplySelect(queryT); // Select and/or GroupBy application
|
|
_resultType = queryT.GetResultType();
|
|
return queryT;
|
|
}
|
|
|
|
internal ObjectQuery<T> CompleteBuild(ObjectQuery<T> queryT, ObjectContext context, bool computeCount, bool wasExtended)
|
|
{
|
|
if (computeCount)
|
|
{
|
|
_count = queryT.Count();
|
|
}
|
|
|
|
queryT = wasExtended ? ApplyQueryableOrderByAndPaging(queryT) : ApplyOrderByAndPaging(queryT);
|
|
queryT = ApplyIncludePaths(queryT);
|
|
|
|
return queryT;
|
|
}
|
|
|
|
private ObjectQuery<T> ApplyWhere(ObjectQuery<T> queryT)
|
|
{
|
|
if (!String.IsNullOrEmpty(_whereExpression))
|
|
{
|
|
queryT = queryT.Where(_whereExpression, _whereParameters);
|
|
}
|
|
return queryT;
|
|
}
|
|
|
|
protected abstract ObjectQuery<T> ApplySelect(ObjectQuery<T> queryT);
|
|
|
|
internal ObjectQuery<T> ApplyOrderBy(ObjectQuery<T> queryT)
|
|
{
|
|
string orderByClause;
|
|
ObjectParameter[] orderByParameters;
|
|
// Apply all possible ordering except the sort expression, because it might only be valid after the query has been extended
|
|
_orderByBuilder.Generate(_resultType, out orderByClause, out orderByParameters, false /*applySortExpression*/);
|
|
|
|
return String.IsNullOrEmpty(orderByClause) ? queryT : queryT.OrderBy(orderByClause, orderByParameters);
|
|
}
|
|
|
|
private ObjectQuery<T> ApplyOrderByAndPaging(ObjectQuery<T> queryT)
|
|
{
|
|
// This re-applys the order-by as part of the skip
|
|
string orderByClause;
|
|
ObjectParameter[] orderByParameters;
|
|
_orderByBuilder.Generate(_resultType, out orderByClause, out orderByParameters, true /*applySortExpression*/);
|
|
bool paging = _arguments.MaximumRows > 0 && _arguments.StartRowIndex >= 0;
|
|
var hasOrderByClause = !String.IsNullOrEmpty(orderByClause);
|
|
|
|
if (paging)
|
|
{
|
|
if (!hasOrderByClause)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceQueryBuilder_PagingRequiresOrderBy);
|
|
}
|
|
queryT = queryT.Skip(orderByClause, _arguments.StartRowIndex.ToString(CultureInfo.InvariantCulture), orderByParameters).Top(_arguments.MaximumRows.ToString(CultureInfo.InvariantCulture), QueryBuilderUtils.EmptyObjectParameters);
|
|
}
|
|
else
|
|
{
|
|
if (hasOrderByClause)
|
|
{
|
|
queryT = queryT.OrderBy(orderByClause, orderByParameters);
|
|
}
|
|
}
|
|
|
|
return queryT;
|
|
}
|
|
|
|
private ObjectQuery<T> ApplyQueryableOrderByAndPaging(ObjectQuery<T> queryT)
|
|
{
|
|
queryT = _orderByBuilder.BuildQueryableOrderBy(queryT) as ObjectQuery<T>;
|
|
bool paging = _arguments.MaximumRows > 0 && _arguments.StartRowIndex >= 0;
|
|
if (paging)
|
|
{
|
|
queryT = queryT.Skip(_arguments.StartRowIndex).Take(_arguments.MaximumRows) as ObjectQuery<T>;
|
|
}
|
|
|
|
return queryT;
|
|
}
|
|
|
|
private ObjectQuery<T> ApplyIncludePaths(ObjectQuery<T> objectQuery)
|
|
{
|
|
if (!string.IsNullOrEmpty(_includePaths))
|
|
{
|
|
foreach (string include in _includePaths.Split(','))
|
|
{
|
|
string trimmedInclude = include.Trim();
|
|
if (!string.IsNullOrEmpty(trimmedInclude))
|
|
{
|
|
objectQuery = objectQuery.Include(trimmedInclude);
|
|
}
|
|
}
|
|
}
|
|
return objectQuery;
|
|
}
|
|
}
|
|
|
|
internal class EntityDataSourceObjectQueryBuilder<T> : EntityDataSourceQueryBuilder<T>
|
|
{
|
|
private EntityDataSourceObjectQueryBuilder(DataSourceSelectArguments arguments,
|
|
string commandText, ObjectParameter[] commandParameters,
|
|
string whereExpression, ObjectParameter[] whereParameters, string entitySetQueryExpression,
|
|
string selectExpression, string groupByExpression, ObjectParameter[] selectParameters,
|
|
OrderByBuilder orderByBuilder,
|
|
string includePaths)
|
|
: base(arguments,
|
|
commandText, commandParameters,
|
|
whereExpression, whereParameters, entitySetQueryExpression,
|
|
selectExpression, groupByExpression, selectParameters,
|
|
orderByBuilder,
|
|
includePaths)
|
|
{
|
|
}
|
|
|
|
static internal EntityDataSourceQueryBuilder<T>.Creator GetCreator()
|
|
{
|
|
return Create;
|
|
}
|
|
|
|
static internal EntityDataSourceQueryBuilder<T> Create(DataSourceSelectArguments arguments,
|
|
string commandText, ObjectParameter[] commandParameters,
|
|
string whereExpression, ObjectParameter[] whereParameters, string entitySetQueryExpression,
|
|
string selectExpression, string groupByExpression, ObjectParameter[] selectParameters,
|
|
OrderByBuilder orderByBuilder,
|
|
string includePaths)
|
|
{
|
|
return new EntityDataSourceObjectQueryBuilder<T>(arguments,
|
|
commandText, commandParameters,
|
|
whereExpression, whereParameters, entitySetQueryExpression,
|
|
selectExpression, groupByExpression, selectParameters,
|
|
orderByBuilder,
|
|
includePaths);
|
|
}
|
|
|
|
protected override ObjectQuery<T> ApplySelect(ObjectQuery<T> queryT)
|
|
{
|
|
return queryT;
|
|
}
|
|
}
|
|
|
|
|
|
internal class EntityDataSourceRecordQueryBuilder : EntityDataSourceQueryBuilder<DbDataRecord>
|
|
{
|
|
private readonly string _selectExpression;
|
|
private readonly string _groupByExpression;
|
|
private readonly ObjectParameter[] _selectParameters;
|
|
|
|
private EntityDataSourceRecordQueryBuilder(DataSourceSelectArguments arguments,
|
|
string commandText, ObjectParameter[] commandParameters,
|
|
string whereExpression, ObjectParameter[] whereParameters, string entitySetQueryExpression,
|
|
string selectExpression, string groupByExpression, ObjectParameter[] selectParameters,
|
|
OrderByBuilder orderByBuilder,
|
|
string includePaths)
|
|
: base(arguments,
|
|
commandText, commandParameters,
|
|
whereExpression, whereParameters, entitySetQueryExpression,
|
|
selectExpression, groupByExpression, selectParameters,
|
|
orderByBuilder,
|
|
includePaths)
|
|
{
|
|
_selectExpression = selectExpression;
|
|
_groupByExpression = groupByExpression;
|
|
_selectParameters = selectParameters;
|
|
}
|
|
|
|
static internal EntityDataSourceQueryBuilder<DbDataRecord> Create(DataSourceSelectArguments arguments,
|
|
string commandText, ObjectParameter[] commandParameters,
|
|
string whereExpression, ObjectParameter[] whereParameters, string entitySetQueryExpression,
|
|
string selectExpression, string groupByExpression, ObjectParameter[] selectParameters,
|
|
OrderByBuilder orderByBuilder,
|
|
string includePaths)
|
|
{
|
|
return new EntityDataSourceRecordQueryBuilder(arguments,
|
|
commandText, commandParameters,
|
|
whereExpression, whereParameters, entitySetQueryExpression,
|
|
selectExpression, groupByExpression, selectParameters,
|
|
orderByBuilder,
|
|
includePaths);
|
|
}
|
|
|
|
protected override ObjectQuery<DbDataRecord> ApplySelect(ObjectQuery<DbDataRecord> queryT)
|
|
{
|
|
Debug.Assert(!String.IsNullOrEmpty(_selectExpression), "Select expression should not be of zero length.");
|
|
|
|
if (!string.IsNullOrEmpty(_groupByExpression))
|
|
{
|
|
queryT = queryT.GroupBy(_groupByExpression, _selectExpression, _selectParameters);
|
|
}
|
|
else
|
|
{
|
|
queryT = queryT.Select(_selectExpression, _selectParameters);
|
|
}
|
|
return queryT;
|
|
}
|
|
}
|
|
|
|
internal static class QueryBuilderUtils
|
|
{
|
|
internal static readonly ObjectParameter[] EmptyObjectParameters = new ObjectParameter[] { };
|
|
|
|
internal static ObjectQuery<T> ConstructQuery<T>(ObjectContext context,
|
|
string entitySetQueryExpression,
|
|
string commandText,
|
|
ObjectParameter[] commandParameters)
|
|
{
|
|
string queryExpression;
|
|
ObjectParameter[] queryParameters;
|
|
if (!string.IsNullOrEmpty(commandText))
|
|
{
|
|
queryExpression = commandText;
|
|
queryParameters = commandParameters;
|
|
}
|
|
else
|
|
{
|
|
queryExpression = entitySetQueryExpression;
|
|
queryParameters = QueryBuilderUtils.EmptyObjectParameters;
|
|
}
|
|
|
|
return context.CreateQuery<T>(queryExpression, queryParameters);
|
|
}
|
|
}
|
|
}
|