Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.Entity/System/Data/WebControls/EntityDataSourceQueryBuilder.cs

@@ -0,0 +1,303 @@
+//---------------------------------------------------------------------
+// <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);
+        }
+    }
+}