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);
}
