protected override void Consume(RelationalDataReader reader) { var npgsqlReader = (NpgsqlDataReader)reader.DbDataReader; Debug.Assert(npgsqlReader.Statements.Count == ModificationCommands.Count, $"Reader has {npgsqlReader.Statements.Count} statements, expected {ModificationCommands.Count}"); var commandIndex = 0; try { while (true) { // Find the next propagating command, if any int nextPropagating; for (nextPropagating = commandIndex; nextPropagating < ModificationCommands.Count && !ModificationCommands[nextPropagating].RequiresResultPropagation; nextPropagating++) { ; } // Go over all non-propagating commands before the next propagating one, // make sure they executed for (; commandIndex < nextPropagating; commandIndex++) { if (npgsqlReader.Statements[commandIndex].Rows == 0) { throw new DbUpdateConcurrencyException( RelationalStrings.UpdateConcurrencyException(1, 0), ModificationCommands[commandIndex].Entries ); } } if (nextPropagating == ModificationCommands.Count) { Debug.Assert(!npgsqlReader.NextResult(), "Expected less resultsets"); break; } // Propagate to results from the reader to the ModificationCommand var modificationCommand = ModificationCommands[commandIndex++]; if (!reader.Read()) { throw new DbUpdateConcurrencyException( RelationalStrings.UpdateConcurrencyException(1, 0), modificationCommand.Entries); } var valueBufferFactory = CreateValueBufferFactory(modificationCommand.ColumnModifications); modificationCommand.PropagateResults(valueBufferFactory.Create(npgsqlReader)); npgsqlReader.NextResult(); } } catch (DbUpdateException) { throw; } catch (Exception ex) { throw new DbUpdateException( RelationalStrings.UpdateStoreException, ex, ModificationCommands[commandIndex].Entries); } }
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; } }
private async Task <object> ExecuteAsync( IOBehavior ioBehavior, [NotNull] IRelationalConnection connection, DbCommandMethod executeMethod, [CanBeNull] IReadOnlyDictionary <string, object> parameterValues, CancellationToken cancellationToken = default(CancellationToken)) { Check.NotNull(connection, nameof(connection)); using (var dbCommand = CreateCommand(connection, parameterValues)) { var mySqlConnection = connection as MySqlRelationalConnection; object result; var opened = false; var commandId = Guid.NewGuid(); var startTime = DateTimeOffset.UtcNow; var stopwatch = Stopwatch.StartNew(); try { if (ioBehavior == IOBehavior.Asynchronous) { // ReSharper disable once PossibleNullReferenceException await mySqlConnection.OpenAsync(cancellationToken, false).ConfigureAwait(false); } else { // ReSharper disable once PossibleNullReferenceException mySqlConnection.Open(); } opened = true; switch (executeMethod) { case DbCommandMethod.ExecuteNonQuery: { result = ioBehavior == IOBehavior.Asynchronous ? await dbCommand.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false) : dbCommand.ExecuteNonQuery(); break; } case DbCommandMethod.ExecuteScalar: { result = ioBehavior == IOBehavior.Asynchronous ? await dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false) : dbCommand.ExecuteScalar(); break; } case DbCommandMethod.ExecuteReader: { var dataReader = ioBehavior == IOBehavior.Asynchronous ? await dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false) : dbCommand.ExecuteReader(); result = new RelationalDataReader(connection, dbCommand, new WrappedMySqlDataReader(dataReader), commandId, Logger); break; } default: { throw new NotSupportedException(); } } Logger.CommandExecuted( dbCommand, executeMethod, commandId, connection.ConnectionId, result, ioBehavior == IOBehavior.Asynchronous, startTime, stopwatch.Elapsed); } catch (Exception exception) { Logger.CommandError( dbCommand, executeMethod, commandId, connection.ConnectionId, exception, ioBehavior == IOBehavior.Asynchronous, startTime, stopwatch.Elapsed); if (opened) { connection.Close(); } throw; } finally { dbCommand.Parameters.Clear(); } return(result); } }
/// <summary> /// Consumes the data reader created by <see cref="Execute" />. /// </summary> /// <param name="reader"> The data reader. </param> protected abstract void Consume([NotNull] RelationalDataReader reader);
protected override object Execute( IRelationalConnection connection, DbCommandMethod executeMethod, IReadOnlyDictionary <string, object> parameterValues) { Check.NotNull(connection, nameof(connection)); var dbCommand = CreateCommand(connection, parameterValues); connection.Open(); var commandId = Guid.NewGuid(); var startTime = DateTimeOffset.UtcNow; var stopwatch = Stopwatch.StartNew(); Logger.CommandExecuting( dbCommand, executeMethod, commandId, connection.ConnectionId, async: false, startTime: startTime); object result; var readerOpen = false; try { switch (executeMethod) { case DbCommandMethod.ExecuteNonQuery: { result = dbCommand.ExecuteNonQuery(); break; } case DbCommandMethod.ExecuteScalar: { result = dbCommand.ExecuteScalar(); break; } case DbCommandMethod.ExecuteReader: { result = new RelationalDataReader( connection, dbCommand, new DbDataReaderDecorator(dbCommand.ExecuteReader()), commandId, Logger); readerOpen = true; break; } default: { throw new NotSupportedException(); } } Logger.CommandExecuted( dbCommand, executeMethod, commandId, connection.ConnectionId, result, false, startTime, stopwatch.Elapsed); } catch (Exception exception) { Logger.CommandError( dbCommand, executeMethod, commandId, connection.ConnectionId, exception, false, startTime, stopwatch.Elapsed); throw; } finally { if (!readerOpen) { dbCommand.Dispose(); connection.Close(); } dbCommand.Parameters.Clear(); } return(result); }
private async Task <object> ExecuteAsync( IOBehavior ioBehavior, [NotNull] IRelationalConnection connection, [NotNull] string executeMethod, [CanBeNull] IReadOnlyDictionary <string, object> parameterValues, bool closeConnection, CancellationToken cancellationToken = default(CancellationToken)) { Check.NotNull(connection, nameof(connection)); Check.NotEmpty(executeMethod, nameof(executeMethod)); using (var dbCommand = CreateCommand(connection, parameterValues)) { cancellationToken.ThrowIfCancellationRequested(); var mySqlConnection = connection as MySqlRelationalConnection; object result; var opened = false; var locked = false; var startTimestamp = Stopwatch.GetTimestamp(); try { if (ioBehavior == IOBehavior.Asynchronous) { // ReSharper disable once PossibleNullReferenceException await mySqlConnection.OpenAsync(cancellationToken).ConfigureAwait(false); } else { // ReSharper disable once PossibleNullReferenceException mySqlConnection.Open(); } opened = true; if (ioBehavior == IOBehavior.Asynchronous) { await mySqlConnection.CommandLock.WaitAsync(cancellationToken).ConfigureAwait(false); } else { mySqlConnection.CommandLock.Wait(cancellationToken); } locked = true; switch (executeMethod) { case nameof(ExecuteNonQuery): { result = ioBehavior == IOBehavior.Asynchronous ? await dbCommand.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false) : dbCommand.ExecuteNonQuery(); break; } case nameof(ExecuteScalar): { result = ioBehavior == IOBehavior.Asynchronous ? await dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false) : dbCommand.ExecuteScalar(); break; } case nameof(ExecuteReader): { var dataReader = ioBehavior == IOBehavior.Asynchronous ? await dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false) : dbCommand.ExecuteReader(); result = new RelationalDataReader(connection, dbCommand, new WrappedMySqlDataReader(dataReader)); break; } default: { throw new NotSupportedException(); } } var currentTimestamp = Stopwatch.GetTimestamp(); Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp); if (closeConnection) { connection.Close(); } return(result); } catch (Exception) { var currentTimestamp = Stopwatch.GetTimestamp(); Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp); if (opened) { connection.Close(); } throw; } finally { if (locked) { mySqlConnection.CommandLock.Release(); } } } }
public ValueTask DisposeAsync() { _dataReader?.Dispose(); _dataReader = null; return(default);
public BadDataRelationalDataReader(RelationalDataReader relationalDataReader, object[] values) { _relationalDataReader = relationalDataReader; _dataReader = new BadDataDataReader(values); }
/// <summary> /// 执行 denglf /// </summary> /// <param name="connection"></param> /// <param name="executeMethod"></param> /// <param name="parameterValues"></param> /// <returns></returns> protected override object Execute(IRelationalConnection connection, DbCommandMethod executeMethod, IReadOnlyDictionary <string, object> parameterValues) { try { if (Check.IsTraceEnabled(base.Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute); } Check.NotNull(connection, nameof(connection)); // 创建命令并打开连接 DbCommand dbCommand = CreateCommand(connection, parameterValues); connection.Open(); Guid commandId = Guid.NewGuid(); DateTimeOffset utcNow = DateTimeOffset.UtcNow; Stopwatch stopwatch = Stopwatch.StartNew(); if (Check.IsTraceEnabled(base.Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.SQL, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute, dbCommand.CommandText); } // 执行命令 Logger.CommandExecuting(dbCommand, executeMethod, commandId, connection.ConnectionId, async: false, utcNow); // 读取数据 bool readerOpen = false; object value; try { switch (executeMethod) { case DbCommandMethod.ExecuteNonQuery: value = dbCommand.ExecuteNonQuery(); break; case DbCommandMethod.ExecuteScalar: value = dbCommand.ExecuteScalar(); break; case DbCommandMethod.ExecuteReader: value = new RelationalDataReader(connection, dbCommand, dbCommand.ExecuteReader(), commandId, Logger); readerOpen = true; break; default: throw new NotSupportedException(); } Logger.CommandExecuted(dbCommand, executeMethod, commandId, connection.ConnectionId, value, async: false, utcNow, stopwatch.Elapsed); } catch (Exception ex) { if (Check.IsErrorEnabled(Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute, ex.ToString()); } Logger.CommandError(dbCommand, executeMethod, commandId, connection.ConnectionId, ex, async: false, utcNow, stopwatch.Elapsed); throw; } finally { if (!readerOpen) { dbCommand.Dispose(); connection.Close(); } dbCommand.Parameters.Clear(); if (Check.IsTraceEnabled(Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleRelationalCommandBuilderFactory, OracleTraceFuncName.Execute); } } return(value); } catch (Exception ex) { if (Check.IsErrorEnabled(Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute, ex.ToString()); } throw; } finally { if (Check.IsTraceEnabled(Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute); } } }
public OeEfCoreDataReaderAsyncEnumerator(RelationalDataReader dataReader, CancellationToken cancellationToken) : base(cancellationToken) { _dataReader = dataReader; }
/// <summary> /// 异步执行 /// </summary> /// <param name="connection"></param> /// <param name="executeMethod"></param> /// <param name="parameterValues"></param> /// <param name="cancellationToken"></param> /// <returns></returns> protected override async Task <object> ExecuteAsync(IRelationalConnection connection, DbCommandMethod executeMethod, IReadOnlyDictionary <string, object> parameterValues, CancellationToken cancellationToken = default(CancellationToken)) { if (Check.IsTraceEnabled(Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.ExecuteAsync); } Check.NotNull(connection, nameof(connection)); // 创建命令并打开连接 DbCommand dbCommand = CreateCommand(connection, parameterValues); await connection.OpenAsync(cancellationToken); Guid commandId = Guid.NewGuid(); DateTimeOffset startTime = DateTimeOffset.UtcNow; Stopwatch stopwatch = Stopwatch.StartNew(); // 执行命令 Logger.CommandExecuting(dbCommand, executeMethod, commandId, connection.ConnectionId, async: true, startTime); // 读取数据 bool readerOpen = false; try { object obj; switch (executeMethod) { case DbCommandMethod.ExecuteNonQuery: obj = await dbCommand.ExecuteNonQueryAsync(cancellationToken); break; case DbCommandMethod.ExecuteScalar: obj = await dbCommand.ExecuteScalarAsync(cancellationToken); break; case DbCommandMethod.ExecuteReader: { DbCommand command = dbCommand; obj = new RelationalDataReader(connection, command, await dbCommand.ExecuteReaderAsync(cancellationToken), commandId, Logger); readerOpen = true; break; } default: throw new NotSupportedException(); } Logger.CommandExecuted(dbCommand, executeMethod, commandId, connection.ConnectionId, obj, async: true, startTime, stopwatch.Elapsed); return(obj); } catch (Exception ex) { if (Check.IsErrorEnabled(Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.ExecuteAsync, ex.ToString()); } Logger.CommandError(dbCommand, executeMethod, commandId, connection.ConnectionId, ex, async: true, startTime, stopwatch.Elapsed); throw; } finally { if (!readerOpen) { dbCommand.Dispose(); connection.Close(); } dbCommand.Parameters.Clear(); if (Check.IsTraceEnabled(Logger?.Logger)) { Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.ExecuteAsync); } } }
public async ValueTask <bool> MoveNextAsync() { try { using (_relationalQueryContext.ConcurrencyDetector.EnterCriticalSection()) { if (_dataReader == null) { var selectExpression = new ParameterValueBasedSelectExpressionOptimizer( _sqlExpressionFactory, _parameterNameGeneratorFactory) .Optimize(_selectExpression, _relationalQueryContext.ParameterValues); var relationalCommand = _querySqlGeneratorFactory.Create().GetCommand(selectExpression); _dataReader = await relationalCommand.ExecuteReaderAsync( new RelationalCommandParameterObject( _relationalQueryContext.Connection, _relationalQueryContext.ParameterValues, _relationalQueryContext.Context, _relationalQueryContext.CommandLogger), _cancellationToken); if (selectExpression.IsNonComposedFromSql()) { var projection = _selectExpression.Projection.ToList(); var readerColumns = Enumerable.Range(0, _dataReader.DbDataReader.FieldCount) .ToDictionary(i => _dataReader.DbDataReader.GetName(i), i => i, StringComparer.OrdinalIgnoreCase); _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) { 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(); 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()) { _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; } }
protected override async Task ConsumeAsync( RelationalDataReader relationalReader, CancellationToken cancellationToken = default) { var commandPosition = 0; int rowsAffected; try { do { while (commandPosition < CommandResultSet.Count && CommandResultSet[commandPosition] == ResultSetMapping.NoResultSet) { commandPosition++; } if (commandPosition < CommandResultSet.Count) { if (ModificationCommands[commandPosition].RequiresResultPropagation) { rowsAffected = 0; do { var tableModification = ModificationCommands[commandPosition]; if (!await relationalReader.ReadAsync(cancellationToken)) { throw new DbUpdateConcurrencyException( RelationalStrings.UpdateConcurrencyException( ModificationCommands.Count(m => m.RequiresResultPropagation), rowsAffected), ModificationCommands[commandPosition].Entries); } var valueBufferFactory = CreateValueBufferFactory(tableModification.ColumnModifications); tableModification.PropagateResults(valueBufferFactory.Create(relationalReader.DbDataReader)); rowsAffected++; }while (++commandPosition < CommandResultSet.Count && CommandResultSet[commandPosition - 1] == ResultSetMapping.NotLastInResultSet); } else { var expectedRowsAffected = 1; while (++commandPosition < CommandResultSet.Count && CommandResultSet[commandPosition - 1] == ResultSetMapping.NotLastInResultSet) { expectedRowsAffected++; } if (relationalReader.Read()) { rowsAffected = relationalReader.DbDataReader.GetInt32(0); if (rowsAffected != expectedRowsAffected) { throw new DbUpdateConcurrencyException( RelationalStrings.UpdateConcurrencyException(expectedRowsAffected, rowsAffected), ModificationCommands[commandPosition - 1].Entries); } } else { throw new DbUpdateConcurrencyException( RelationalStrings.UpdateConcurrencyException(1, 0), ModificationCommands[commandPosition - 1].Entries); } } } }while (commandPosition < CommandResultSet.Count && await relationalReader.DbDataReader.NextResultAsync(cancellationToken)); } catch (DbUpdateException) { throw; } catch (Exception ex) { throw new DbUpdateException( RelationalStrings.UpdateStoreException, ex, ModificationCommands[commandPosition].Entries); } }
private async Task <object> ExecuteAsync( IOBehavior ioBehavior, [NotNull] IRelationalConnection connection, [NotNull] string executeMethod, [CanBeNull] IReadOnlyDictionary <string, object> parameterValues, bool closeConnection, CancellationToken cancellationToken = default(CancellationToken)) { Check.NotNull(connection, nameof(connection)); Check.NotEmpty(executeMethod, nameof(executeMethod)); var dbCommand = CreateCommand(connection, parameterValues); object result; cancellationToken.ThrowIfCancellationRequested(); var mySqlConnection = connection as MySqlRelationalConnection; var locked = false; try { if (ioBehavior == IOBehavior.Asynchronous) { // ReSharper disable once PossibleNullReferenceException await mySqlConnection.PoolingOpenAsync(cancellationToken).ConfigureAwait(false); await mySqlConnection.Lock.WaitAsync(cancellationToken).ConfigureAwait(false); } else { // ReSharper disable once PossibleNullReferenceException mySqlConnection.PoolingOpen(); mySqlConnection.Lock.Wait(cancellationToken); } locked = true; switch (executeMethod) { case nameof(ExecuteNonQuery): { using (dbCommand) { if (ioBehavior == IOBehavior.Asynchronous) { result = await dbCommand.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); } else { result = dbCommand.ExecuteNonQuery(); } } break; } case nameof(ExecuteScalar): { using (dbCommand) { if (ioBehavior == IOBehavior.Asynchronous) { result = await dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false); } else { result = dbCommand.ExecuteScalar(); } } break; } case nameof(ExecuteReader): { try { MySqlDataReader dataReader; if (ioBehavior == IOBehavior.Asynchronous) { dataReader = await dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false) as MySqlDataReader; } else { dataReader = dbCommand.ExecuteReader() as MySqlDataReader; } result = new RelationalDataReader(connection, dbCommand, new SynchronizedMySqlDataReader(dataReader, mySqlConnection)); } catch (Exception) { dbCommand.Dispose(); throw; } break; } default: { throw new NotSupportedException(); } } } finally { if (locked && executeMethod != nameof(ExecuteReader)) { // if calling any other method, the command has finished executing and the lock can be released immediately // ReSharper disable once PossibleNullReferenceException mySqlConnection.Lock.Release(); mySqlConnection.PoolingClose(); } // ReSharper disable once PossibleNullReferenceException if (!mySqlConnection.Pooling && closeConnection) { connection.Close(); } } return(result); }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> protected virtual object Execute( [NotNull] IRelationalConnection connection, [NotNull] string executeMethod, [CanBeNull] IReadOnlyDictionary <string, object> parameterValues, bool closeConnection = true) { Check.NotNull(connection, nameof(connection)); Check.NotEmpty(executeMethod, nameof(executeMethod)); var dbCommand = CreateCommand(connection, parameterValues); connection.Open(); var startTimestamp = Stopwatch.GetTimestamp(); var instanceId = Guid.NewGuid(); DiagnosticSource.WriteCommandBefore( connection.ConnectionId, dbCommand, executeMethod, instanceId, startTimestamp, async: false); object result; try { switch (executeMethod) { case nameof(ExecuteNonQuery): { using (dbCommand) { result = dbCommand.ExecuteNonQuery(); } break; } case nameof(ExecuteScalar): { using (dbCommand) { result = dbCommand.ExecuteScalar(); } break; } case nameof(ExecuteReader): { try { result = new RelationalDataReader( connection, dbCommand, dbCommand.ExecuteReader(), DiagnosticSource); } catch { dbCommand.Dispose(); throw; } break; } default: { throw new NotSupportedException(); } } var currentTimestamp = Stopwatch.GetTimestamp(); Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp); DiagnosticSource.WriteCommandAfter( connection.ConnectionId, dbCommand, executeMethod, result, instanceId, startTimestamp, currentTimestamp); if (closeConnection) { connection.Close(); } } catch (Exception exception) { var currentTimestamp = Stopwatch.GetTimestamp(); Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp); DiagnosticSource.WriteCommandError( connection.ConnectionId, dbCommand, executeMethod, instanceId, startTimestamp, currentTimestamp, exception, async: false); connection.Close(); throw; } finally { dbCommand.Parameters.Clear(); } return(result); }
protected virtual async Task <object> ExecuteAsync( [NotNull] IRelationalConnection connection, [NotNull] string executeMethod, [CanBeNull] IReadOnlyDictionary <string, object> parameterValues, bool openConnection, bool closeConnection, CancellationToken cancellationToken = default(CancellationToken)) { Check.NotNull(connection, nameof(connection)); Check.NotEmpty(executeMethod, nameof(executeMethod)); var dbCommand = CreateCommand(connection, parameterValues); object result; if (openConnection) { await connection.OpenAsync(cancellationToken); } var startTimestamp = Stopwatch.GetTimestamp(); var instanceId = Guid.NewGuid(); DiagnosticSource.WriteCommandBefore( dbCommand, executeMethod, instanceId, startTimestamp, async: true); try { switch (executeMethod) { case nameof(ExecuteNonQuery): { using (dbCommand) { result = await dbCommand.ExecuteNonQueryAsync(cancellationToken); } break; } case nameof(ExecuteScalar): { using (dbCommand) { result = await dbCommand.ExecuteScalarAsync(cancellationToken); } break; } case nameof(ExecuteReader): { try { result = new RelationalDataReader( openConnection ? connection : null, dbCommand, await dbCommand.ExecuteReaderAsync(cancellationToken)); } catch { dbCommand.Dispose(); throw; } break; } default: { throw new NotSupportedException(); } } var currentTimestamp = Stopwatch.GetTimestamp(); Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp); DiagnosticSource.WriteCommandAfter( dbCommand, executeMethod, instanceId, startTimestamp, currentTimestamp, async: true); } catch (Exception exception) { var currentTimestamp = Stopwatch.GetTimestamp(); Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp); DiagnosticSource.WriteCommandError( dbCommand, executeMethod, instanceId, startTimestamp, currentTimestamp, exception, async: true); if (openConnection && !closeConnection) { connection.Close(); } throw; } finally { if (closeConnection) { connection.Close(); } } return(result); }
protected override async Task <int> ConsumeResultSetWithPropagationAsync( int commandIndex, [NotNull] RelationalDataReader reader, CancellationToken cancellationToken) { return(commandIndex); }
protected override object Execute( IRelationalConnection connection, DbCommandMethod executeMethod, IReadOnlyDictionary <string, object> parameterValues) { GaxPreconditions.CheckNotNull(connection, nameof(connection)); var dbCommand = CreateCommand(connection, parameterValues); connection.Open(); var commandId = Guid.NewGuid(); var startTime = DateTimeOffset.UtcNow; var stopwatch = Stopwatch.StartNew(); Logger.CommandExecuting( dbCommand, executeMethod, commandId, connection.ConnectionId, false, startTime); object result; var readerOpen = false; try { //Note that adds/updates/deletes get intercepted at the //modificationcommandbatch level and normally do not get translated //into ADO.NET commands here. However, there are features in EF that //allow raw DML to be sent to the database which end up here and we need //to create the proper command and throw a useful exception. //TODO(benwu): there may be a way we can accept a non-DML text version of updates // but we'll need to send it thru detailed design review. switch (executeMethod) { case DbCommandMethod.ExecuteNonQuery: { result = dbCommand.ExecuteNonQuery(); break; } case DbCommandMethod.ExecuteScalar: { result = dbCommand.ExecuteScalar(); break; } case DbCommandMethod.ExecuteReader: { result = new RelationalDataReader( connection, dbCommand, dbCommand.ExecuteReader(), commandId, Logger); readerOpen = true; break; } default: { throw new NotSupportedException(); } } Logger.CommandExecuted( dbCommand, executeMethod, commandId, connection.ConnectionId, result, false, startTime, stopwatch.Elapsed); } catch (Exception exception) { Logger.CommandError( dbCommand, executeMethod, commandId, connection.ConnectionId, exception, false, startTime, stopwatch.Elapsed); throw; } finally { if (!readerOpen) { dbCommand.Dispose(); connection.Close(); } dbCommand.Parameters.Clear(); } return(result); }
protected override int ConsumeResultSetWithPropagation(int commandIndex, [NotNull] RelationalDataReader reader) { return(commandIndex); }
private async Task <object> ExecuteAsync( IOBehavior ioBehavior, [NotNull] IRelationalConnection connection, DbCommandMethod executeMethod, [CanBeNull] IReadOnlyDictionary <string, object> parameterValues, CancellationToken cancellationToken = default(CancellationToken)) { Check.NotNull(connection, nameof(connection)); /*using (DbCommand */ _dbCommand = CreateCommand(connection, parameterValues); /*)*/ { var fbConnection = connection as FbRelationalConnection; object result; var opened = false; var commandId = Guid.NewGuid(); var startTime = DateTimeOffset.UtcNow; var stopwatch = Stopwatch.StartNew(); try { if (ioBehavior == IOBehavior.Asynchronous) { // ReSharper disable once PossibleNullReferenceException await fbConnection.OpenAsync(cancellationToken).ConfigureAwait(false); } else { // ReSharper disable once PossibleNullReferenceException fbConnection.Open(); } opened = true; if (_dbCommand.CommandText.ToUpper().Contains("INSERT ") && _dbCommand.CommandText.ToUpper().Contains(" RETURNING ")) { executeMethod = DbCommandMethod.ExecuteScalar; } switch (executeMethod) { case DbCommandMethod.ExecuteNonQuery: { result = ioBehavior == IOBehavior.Asynchronous ? await _dbCommand.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false) : _dbCommand.ExecuteNonQuery(); break; } case DbCommandMethod.ExecuteScalar: { result = ioBehavior == IOBehavior.Asynchronous ? await _dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false) : _dbCommand.ExecuteScalar(); break; } case DbCommandMethod.ExecuteReader: { var dataReader = ioBehavior == IOBehavior.Asynchronous ? await _dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false) : _dbCommand.ExecuteReader(); _wrp = new WrappedFirebirdDataReader(dataReader); _rdr = new RelationalDataReader(connection, _dbCommand, _wrp, commandId, Logger); result = _rdr; break; } default: { throw new NotSupportedException(); } } Logger.CommandExecuted( _dbCommand, executeMethod, commandId, connection.ConnectionId, result, ioBehavior == IOBehavior.Asynchronous, startTime, stopwatch.Elapsed); } catch (Exception exception) { Logger.CommandError( _dbCommand, executeMethod, commandId, connection.ConnectionId, exception, ioBehavior == IOBehavior.Asynchronous, startTime, stopwatch.Elapsed); if (opened) { connection.Close(); } throw; } finally { _dbCommand.Parameters.Clear(); } return(result); } }
protected override Task ConsumeAsync(RelationalDataReader reader, CancellationToken cancellationToken = default(CancellationToken)) { return(Task.Run(() => Consume(reader), cancellationToken)); }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> protected virtual async Task <object> ExecuteAsync( [NotNull] IRelationalConnection connection, DbCommandMethod executeMethod, [CanBeNull] IReadOnlyDictionary <string, object> parameterValues, CancellationToken cancellationToken = default) { Check.NotNull(connection, nameof(connection)); var dbCommand = CreateCommand(connection, parameterValues); await connection.OpenAsync(cancellationToken); var commandId = Guid.NewGuid(); var startTime = DateTimeOffset.UtcNow; var stopwatch = Stopwatch.StartNew(); Logger.CommandExecuting( dbCommand, executeMethod, commandId, connection.ConnectionId, async: true, startTime: startTime); object result; var readerOpen = false; try { switch (executeMethod) { case DbCommandMethod.ExecuteNonQuery: { result = await dbCommand.ExecuteNonQueryAsync(cancellationToken); break; } case DbCommandMethod.ExecuteScalar: { result = await dbCommand.ExecuteScalarAsync(cancellationToken); break; } case DbCommandMethod.ExecuteReader: { result = new RelationalDataReader( connection, dbCommand, await dbCommand.ExecuteReaderAsync(cancellationToken), commandId, Logger); readerOpen = true; break; } default: { throw new NotSupportedException(); } } Logger.CommandExecuted( dbCommand, executeMethod, commandId, connection.ConnectionId, result, true, startTime, stopwatch.Elapsed); } catch (Exception exception) { Logger.CommandError( dbCommand, executeMethod, commandId, connection.ConnectionId, exception, true, startTime, stopwatch.Elapsed); throw; } finally { if (!readerOpen) { dbCommand.Parameters.Clear(); dbCommand.Dispose(); connection.Close(); } } return(result); }
public OeEfCoreDataReaderAsyncEnumerator(RelationalDataReader dataReader) { _dataReader = dataReader; }
public void Dispose() { _dataReader?.Dispose(); _dataReader = null; _relationalQueryContext.Connection.Close(); }
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; } }
/// <summary> /// Consumes the data reader created by <see cref="ExecuteAsync" />. /// </summary> /// <param name="reader"> The data reader. </param> /// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param> /// <returns> A task that represents the asynchronous operation. </returns> protected abstract Task ConsumeAsync( [NotNull] RelationalDataReader reader, CancellationToken cancellationToken = default);
public bool MoveNext() { try { if (_dataReader == null) { 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); if (selectExpression.IsNonComposedFromSql()) { var projection = _selectExpression.Projection.ToList(); var readerColumns = Enumerable.Range(0, _dataReader.DbDataReader.FieldCount) .ToDictionary(i => _dataReader.DbDataReader.GetName(i), i => i, StringComparer.OrdinalIgnoreCase); _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) { 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(); _resultCoordinator.HasNext = null; Current = hasNext ? _shaper(_relationalQueryContext, _dataReader.DbDataReader, _indexMap, _resultCoordinator) : default; return(hasNext); } catch (Exception exception) { _logger.QueryIterationFailed(_contextType, exception); throw; } }
protected virtual async Task<object> ExecuteAsync( [NotNull] IRelationalConnection connection, [NotNull] string executeMethod, [CanBeNull] IReadOnlyDictionary<string, object> parameterValues, bool openConnection, bool closeConnection, CancellationToken cancellationToken = default(CancellationToken)) { Check.NotNull(connection, nameof(connection)); Check.NotEmpty(executeMethod, nameof(executeMethod)); var dbCommand = CreateCommand(connection, parameterValues); object result; if (openConnection) { await connection.OpenAsync(cancellationToken); } var startTimestamp = Stopwatch.GetTimestamp(); var instanceId = Guid.NewGuid(); DiagnosticSource.WriteCommandBefore( dbCommand, executeMethod, instanceId, startTimestamp, async: true); try { switch (executeMethod) { case nameof(ExecuteNonQuery): { using (dbCommand) { result = await dbCommand.ExecuteNonQueryAsync(cancellationToken); } break; } case nameof(ExecuteScalar): { using (dbCommand) { result = await dbCommand.ExecuteScalarAsync(cancellationToken); } break; } case nameof(ExecuteReader): { try { result = new RelationalDataReader( openConnection ? connection : null, dbCommand, await dbCommand.ExecuteReaderAsync(cancellationToken)); } catch { dbCommand.Dispose(); throw; } break; } default: { throw new NotSupportedException(); } } var currentTimestamp = Stopwatch.GetTimestamp(); Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp); DiagnosticSource.WriteCommandAfter( dbCommand, executeMethod, instanceId, startTimestamp, currentTimestamp, async: true); } catch (Exception exception) { var currentTimestamp = Stopwatch.GetTimestamp(); Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp); DiagnosticSource.WriteCommandError( dbCommand, executeMethod, instanceId, startTimestamp, currentTimestamp, exception, async: true); if (openConnection && !closeConnection) { connection.Close(); } throw; } finally { if (closeConnection) { connection.Close(); } } return result; }
/// <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 SplitQueryDataReaderContext( [NotNull] RelationalDataReader dataReader) { DataReader = dataReader; }
public void Dispose() { _dataReader?.Dispose(); _dataReader = null; }
protected virtual async Task <object> ExecuteAsync( [NotNull] IRelationalConnection connection, [NotNull] string executeMethod, bool openConnection, bool closeConnection, CancellationToken cancellationToken = default(CancellationToken), [CanBeNull] IReadOnlyDictionary <string, object> parameterValues = null) { var dbCommand = CreateCommand(connection, parameterValues); WriteDiagnostic( RelationalDiagnostics.BeforeExecuteCommand, dbCommand, executeMethod, async: true); object result; if (openConnection) { await connection.OpenAsync(cancellationToken); } Stopwatch stopwatch = null; try { if (Logger.IsEnabled(LogLevel.Information)) { stopwatch = Stopwatch.StartNew(); } switch (executeMethod) { case nameof(ExecuteNonQuery): { using (dbCommand) { result = await dbCommand.ExecuteNonQueryAsync(cancellationToken); } break; } case nameof(ExecuteScalar): { using (dbCommand) { result = await dbCommand.ExecuteScalarAsync(cancellationToken); } break; } case nameof(ExecuteReader): { try { result = new RelationalDataReader( openConnection ? connection : null, dbCommand, await dbCommand.ExecuteReaderAsync(cancellationToken)); } catch { dbCommand.Dispose(); throw; } break; } default: { throw new NotSupportedException(); } } stopwatch?.Stop(); Logger.LogCommandExecuted(dbCommand, stopwatch?.ElapsedMilliseconds); } catch (Exception exception) { stopwatch?.Stop(); Logger.LogCommandExecuted(dbCommand, stopwatch?.ElapsedMilliseconds); DiagnosticSource .WriteCommandError( dbCommand, executeMethod, async: true, exception: exception); if (openConnection && !closeConnection) { connection.Close(); } throw; } finally { if (closeConnection) { connection.Close(); } } WriteDiagnostic( RelationalDiagnostics.AfterExecuteCommand, dbCommand, executeMethod, async: true); return(result); }