Refactor RelationalShapedQueryCompilingExpressionVisitor

All.sln.DotSettings

@@ -199,6 +199,7 @@ Licensed under the Apache License, Version 2.0. See License.txt in the project r
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002EXml_002ECodeStyle_002EFormatSettingsUpgrade_002EXmlMoveToCommonFormatterSettingsUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=annotatable/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=fallbacks/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=initializers/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=keyless/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=materializer/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=materializers/@EntryIndexedValue">True</s:Boolean>	

src/EFCore.Relational/Query/Internal/CollectionMaterializationContext.cs

@@ -0,0 +1,35 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.EntityFrameworkCore.Query.Internal
+{
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public class CollectionMaterializationContext
+    {
+        public CollectionMaterializationContext(object parent, object collection, object[] parentIdentifier, object[] outerIdentifier)
+        {
+            Parent = parent;
+            Collection = collection;
+            ParentIdentifier = parentIdentifier;
+            OuterIdentifier = outerIdentifier;
+            ResultContext = new ResultContext();
+        }
+
+        public virtual ResultContext ResultContext { get; }
+        public virtual object Parent { get; }
+        public virtual object Collection { get; }
+        public virtual object[] ParentIdentifier { get; }
+        public virtual object[] OuterIdentifier { get; }
+        public virtual object[] SelfIdentifier { get; private set; }
+
+        public virtual void UpdateSelfIdentifier(object[] selfIdentifier)
+        {
+            SelfIdentifier = selfIdentifier;
+        }
+    }
+}

src/EFCore.Relational/Query/Internal/QueryingEnumerable.cs

@@ -0,0 +1,311 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace Microsoft.EntityFrameworkCore.Query.Internal
+{
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public class QueryingEnumerable<T> : IEnumerable<T>, IAsyncEnumerable<T>
+    {
+        private readonly RelationalQueryContext _relationalQueryContext;
+        private readonly RelationalCommandCache _relationalCommandCache;
+        private readonly IReadOnlyList<string> _columnNames;
+        private readonly Func<QueryContext, DbDataReader, ResultContext, int[], ResultCoordinator, T> _shaper;
+        private readonly Type _contextType;
+        private readonly IDiagnosticsLogger<DbLoggerCategory.Query> _logger;
+
+        public QueryingEnumerable(
+            RelationalQueryContext relationalQueryContext,
+            RelationalCommandCache relationalCommandCache,
+            IReadOnlyList<string> columnNames,
+            Func<QueryContext, DbDataReader, ResultContext, int[], ResultCoordinator, T> shaper,
+            Type contextType,
+            IDiagnosticsLogger<DbLoggerCategory.Query> logger)
+        {
+            _relationalQueryContext = relationalQueryContext;
+            _relationalCommandCache = relationalCommandCache;
+            _columnNames = columnNames;
+            _shaper = shaper;
+            _contextType = contextType;
+            _logger = logger;
+        }
+
+        public virtual IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+            => new AsyncEnumerator(this, cancellationToken);
+
+        public virtual IEnumerator<T> GetEnumerator() => new Enumerator(this);
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        private sealed class Enumerator : IEnumerator<T>
+        {
+            private readonly RelationalQueryContext _relationalQueryContext;
+            private readonly RelationalCommandCache _relationalCommandCache;
+            private readonly IReadOnlyList<string> _columnNames;
+            private readonly Func<QueryContext, DbDataReader, ResultContext, int[], ResultCoordinator, T> _shaper;
+            private readonly Type _contextType;
+            private readonly IDiagnosticsLogger<DbLoggerCategory.Query> _logger;
+
+            private RelationalDataReader _dataReader;
+            private int[] _indexMap;
+            private ResultCoordinator _resultCoordinator;
+
+            public Enumerator(QueryingEnumerable<T> queryingEnumerable)
+            {
+                _relationalQueryContext = queryingEnumerable._relationalQueryContext;
+                _relationalCommandCache = queryingEnumerable._relationalCommandCache;
+                _columnNames = queryingEnumerable._columnNames;
+                _shaper = queryingEnumerable._shaper;
+                _contextType = queryingEnumerable._contextType;
+                _logger = queryingEnumerable._logger;
+            }
+
+            public T Current { get; private set; }
+
+            object IEnumerator.Current => Current;
+
+            public bool MoveNext()
+            {
+                try
+                {
+                    using (_relationalQueryContext.ConcurrencyDetector.EnterCriticalSection())
+                    {
+                        if (_dataReader == null)
+                        {
+                            var relationalCommand = _relationalCommandCache.GetRelationalCommand(
+                                _relationalQueryContext.ParameterValues);
+
+                            _dataReader
+                                = relationalCommand.ExecuteReader(
+                                    new RelationalCommandParameterObject(
+                                        _relationalQueryContext.Connection,
+                                        _relationalQueryContext.ParameterValues,
+                                        _relationalQueryContext.Context,
+                                        _relationalQueryContext.CommandLogger));
+
+                            // Non-Composed FromSql
+                            if (_columnNames != null)
+                            {
+                                var readerColumns = Enumerable.Range(0, _dataReader.DbDataReader.FieldCount)
+                                    .ToDictionary(i => _dataReader.DbDataReader.GetName(i), i => i, StringComparer.OrdinalIgnoreCase);
+
+                                _indexMap = new int[_columnNames.Count];
+                                for (var i = 0; i < _columnNames.Count; i++)
+                                {
+                                    var columnName = _columnNames[i];
+                                    if (!readerColumns.TryGetValue(columnName, out var ordinal))
+                                    {
+                                        throw new InvalidOperationException(RelationalStrings.FromSqlMissingColumn(columnName));
+                                    }
+
+                                    _indexMap[i] = ordinal;
+                                }
+                            }
+                            else
+                            {
+                                _indexMap = null;
+                            }
+
+                            _resultCoordinator = new ResultCoordinator();
+                        }
+
+                        var hasNext = _resultCoordinator.HasNext ?? _dataReader.Read();
+                        Current = default;
+
+                        if (hasNext)
+                        {
+                            while (true)
+                            {
+                                _resultCoordinator.ResultReady = true;
+                                _resultCoordinator.HasNext = null;
+                                Current = _shaper(
+                                    _relationalQueryContext, _dataReader.DbDataReader,
+                                    _resultCoordinator.ResultContext, _indexMap, _resultCoordinator);
+                                if (_resultCoordinator.ResultReady)
+                                {
+                                    // We generated a result so null out previously stored values
+                                    _resultCoordinator.ResultContext.Values = null;
+                                    break;
+                                }
+
+                                if (!_dataReader.Read())
+                                {
+                                    _resultCoordinator.HasNext = false;
+                                    // Enumeration has ended, materialize last element
+                                    _resultCoordinator.ResultReady = true;
+                                    Current = _shaper(
+                                        _relationalQueryContext, _dataReader.DbDataReader,
+                                        _resultCoordinator.ResultContext, _indexMap, _resultCoordinator);
+
+                                    break;
+                                }
+                            }
+                        }
+
+                        return hasNext;
+                    }
+                }
+                catch (Exception exception)
+                {
+                    _logger.QueryIterationFailed(_contextType, exception);
+
+                    throw;
+                }
+            }
+
+            public void Dispose()
+            {
+                _dataReader?.Dispose();
+                _dataReader = null;
+            }
+
+            public void Reset() => throw new NotImplementedException();
+        }
+
+        private sealed class AsyncEnumerator : IAsyncEnumerator<T>
+        {
+            private readonly RelationalQueryContext _relationalQueryContext;
+            private readonly RelationalCommandCache _relationalCommandCache;
+            private readonly IReadOnlyList<string> _columnNames;
+            private readonly Func<QueryContext, DbDataReader, ResultContext, int[], ResultCoordinator, T> _shaper;
+            private readonly Type _contextType;
+            private readonly IDiagnosticsLogger<DbLoggerCategory.Query> _logger;
+            private readonly CancellationToken _cancellationToken;
+
+            private RelationalDataReader _dataReader;
+            private int[] _indexMap;
+            private ResultCoordinator _resultCoordinator;
+
+            public AsyncEnumerator(
+                QueryingEnumerable<T> queryingEnumerable,
+                CancellationToken cancellationToken)
+            {
+                _relationalQueryContext = queryingEnumerable._relationalQueryContext;
+                _relationalCommandCache = queryingEnumerable._relationalCommandCache;
+                _columnNames = queryingEnumerable._columnNames;
+                _shaper = queryingEnumerable._shaper;
+                _contextType = queryingEnumerable._contextType;
+                _logger = queryingEnumerable._logger;
+                _cancellationToken = cancellationToken;
+            }
+
+            public T Current { get; private set; }
+
+            public async ValueTask<bool> MoveNextAsync()
+            {
+                try
+                {
+                    using (_relationalQueryContext.ConcurrencyDetector.EnterCriticalSection())
+                    {
+                        if (_dataReader == null)
+                        {
+                            var relationalCommand = _relationalCommandCache.GetRelationalCommand(
+                                _relationalQueryContext.ParameterValues);
+
+                            _dataReader
+                                = await relationalCommand.ExecuteReaderAsync(
+                                    new RelationalCommandParameterObject(
+                                        _relationalQueryContext.Connection,
+                                        _relationalQueryContext.ParameterValues,
+                                        _relationalQueryContext.Context,
+                                        _relationalQueryContext.CommandLogger),
+                                    _cancellationToken);
+
+                            // Non-Composed FromSql
+                            if (_columnNames != null)
+                            {
+                                var readerColumns = Enumerable.Range(0, _dataReader.DbDataReader.FieldCount)
+                                    .ToDictionary(i => _dataReader.DbDataReader.GetName(i), i => i, StringComparer.OrdinalIgnoreCase);
+
+                                _indexMap = new int[_columnNames.Count];
+                                for (var i = 0; i < _columnNames.Count; i++)
+                                {
+                                    var columnName = _columnNames[i];
+                                    if (!readerColumns.TryGetValue(columnName, out var ordinal))
+                                    {
+                                        throw new InvalidOperationException(RelationalStrings.FromSqlMissingColumn(columnName));
+                                    }
+
+                                    _indexMap[i] = ordinal;
+                                }
+                            }
+                            else
+                            {
+                                _indexMap = null;
+                            }
+
+                            _resultCoordinator = new ResultCoordinator();
+                        }
+
+                        var hasNext = _resultCoordinator.HasNext ?? await _dataReader.ReadAsync(_cancellationToken);
+                        Current = default;
+
+                        if (hasNext)
+                        {
+                            while (true)
+                            {
+                                _resultCoordinator.ResultReady = true;
+                                _resultCoordinator.HasNext = null;
+                                Current = _shaper(
+                                    _relationalQueryContext, _dataReader.DbDataReader,
+                                    _resultCoordinator.ResultContext, _indexMap, _resultCoordinator);
+                                if (_resultCoordinator.ResultReady)
+                                {
+                                    // We generated a result so null out previously stored values
+                                    _resultCoordinator.ResultContext.Values = null;
+                                    break;
+                                }
+
+                                if (!await _dataReader.ReadAsync(_cancellationToken))
+                                {
+                                    _resultCoordinator.HasNext = false;
+                                    // Enumeration has ended, materialize last element
+                                    _resultCoordinator.ResultReady = true;
+                                    Current = _shaper(
+                                        _relationalQueryContext, _dataReader.DbDataReader,
+                                        _resultCoordinator.ResultContext, _indexMap, _resultCoordinator);
+
+                                    break;
+                                }
+                            }
+                        }
+
+                        return hasNext;
+                    }
+                }
+                catch (Exception exception)
+                {
+                    _logger.QueryIterationFailed(_contextType, exception);
+
+                    throw;
+                }
+            }
+
+            public ValueTask DisposeAsync()
+            {
+                if (_dataReader != null)
+                {
+                    var dataReader = _dataReader;
+                    _dataReader = null;
+
+                    return dataReader.DisposeAsync();
+                }
+
+                return default;
+            }
+        }
+    }
+}