Esempio n. 1
0
                public async Task <bool> MoveNext(CancellationToken cancellationToken)
                {
                    try
                    {
                        if (_dataReader == null)
                        {
                            await _relationalQueryContext.Connection.OpenAsync(cancellationToken);

                            try
                            {
                                var selectExpression = new ParameterValueBasedSelectExpressionOptimizer(
                                    _sqlExpressionFactory,
                                    _parameterNameGeneratorFactory)
                                                       .Optimize(_selectExpression, _relationalQueryContext.ParameterValues);

                                var relationalCommand = _querySqlGeneratorFactory.Create().GetCommand(selectExpression);

                                _dataReader
                                    = await relationalCommand.ExecuteReaderAsync(
                                          _relationalQueryContext.Connection,
                                          _relationalQueryContext.ParameterValues,
                                          _relationalQueryContext.CommandLogger,
                                          cancellationToken);

                                _resultCoordinator = new ResultCoordinator();
                            }
                            catch (Exception)
                            {
                                // If failure happens creating the data reader, then it won't be available to
                                // handle closing the connection, so do it explicitly here to preserve ref counting.
                                _relationalQueryContext.Connection.Close();

                                throw;
                            }
                        }

                        var hasNext = _resultCoordinator.HasNext ?? await _dataReader.ReadAsync(cancellationToken);

                        _resultCoordinator.HasNext = null;

                        Current
                            = hasNext
                                ? await _shaper(_relationalQueryContext, _dataReader.DbDataReader, _resultCoordinator)
                                : default;

                        return(hasNext);
                    }
                    catch (Exception exception)
                    {
                        _logger.QueryIterationFailed(_contextType, exception);

                        throw;
                    }
                }
                public bool MoveNext()
                {
                    try
                    {
                        if (_dataReader == null)
                        {
                            _relationalQueryContext.Connection.Open();

                            try
                            {
                                var projection = _selectExpression.Projection.ToList();

                                var selectExpression = new ParameterValueBasedSelectExpressionOptimizer(
                                    _sqlExpressionFactory,
                                    _parameterNameGeneratorFactory)
                                                       .Optimize(_selectExpression, _relationalQueryContext.ParameterValues);

                                var relationalCommand = _querySqlGeneratorFactory.Create().GetCommand(selectExpression);

                                _dataReader
                                    = relationalCommand.ExecuteReader(
                                          _relationalQueryContext.Connection,
                                          _relationalQueryContext.ParameterValues,
                                          _relationalQueryContext.CommandLogger);

                                var readerColumns = Enumerable.Range(0, _dataReader.DbDataReader.FieldCount)
                                                    .Select(
                                    i => new
                                {
                                    Name    = _dataReader.DbDataReader.GetName(i),
                                    Ordinal = i
                                }).ToList();

                                _indexMap = new int[projection.Count];

                                for (var i = 0; i < projection.Count; i++)
                                {
                                    if (projection[i].Expression is ColumnExpression columnExpression)
                                    {
                                        var columnName = columnExpression.Name;

                                        if (columnName != null)
                                        {
                                            var readerColumn
                                                = readerColumns.SingleOrDefault(
                                                      c =>
                                                      string.Equals(columnName, c.Name, StringComparison.OrdinalIgnoreCase));

                                            if (readerColumn == null)
                                            {
                                                throw new InvalidOperationException(RelationalStrings.FromSqlMissingColumn(columnName));
                                            }

                                            _indexMap[i] = readerColumn.Ordinal;
                                        }
                                    }
                                }
                            }
                            catch (Exception)
                            {
                                // If failure happens creating the data reader, then it won't be available to
                                // handle closing the connection, so do it explicitly here to preserve ref counting.
                                _relationalQueryContext.Connection.Close();

                                throw;
                            }
                        }

                        var hasNext = _dataReader.Read();

                        Current
                            = hasNext
                                ? _shaper(_relationalQueryContext, _dataReader.DbDataReader, _indexMap)
                                : default;

                        return(hasNext);
                    }
                    catch (Exception exception)
                    {
                        _logger.QueryIterationFailed(_contextType, exception);

                        throw;
                    }
                }