public RelationalDataReader ExecuteReader(RelationalCommandParameterObject parameterObject)
{
var connection = parameterObject.Connection;
var errorNumber = PreExecution(connection);
var result = _realRelationalCommand.ExecuteReader(parameterObject);
if (errorNumber.HasValue)
{
connection.DbConnection.Close();
result.Dispose(); // Normally, in non-test case, reader is disposed by using in caller code
throw SqlExceptionFactory.CreateSqlException(errorNumber.Value);
}
return(result);
}
public Task <int> ExecuteNonQueryAsync(
IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues,
CancellationToken cancellationToken = new CancellationToken())
{
var errorNumber = PreExecution(connection);
var result = _realRelationalCommand.ExecuteNonQueryAsync(connection, parameterValues, cancellationToken);
if (errorNumber.HasValue)
{
connection.DbConnection.Close();
throw SqlExceptionFactory.CreateSqlException(errorNumber.Value);
}
return(result);
}
public RelationalDataReader ExecuteReader(
IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues)
{
var errorNumber = PreExecution(connection);
var result = _realRelationalCommand.ExecuteReader(connection, parameterValues);
if (errorNumber.HasValue)
{
connection.DbConnection.Close();
result.Dispose(); // Normally, in non-test case, reader is disposed by using in caller code
throw SqlExceptionFactory.CreateSqlException(errorNumber.Value);
}
return(result);
}
public async Task <object> ExecuteScalarAsync(
RelationalCommandParameterObject parameterObject,
CancellationToken cancellationToken = new CancellationToken())
{
var connection = parameterObject.Connection;
var errorNumber = PreExecution(connection);
var result = await _realRelationalCommand.ExecuteScalarAsync(parameterObject, cancellationToken);
if (errorNumber.HasValue)
{
connection.DbConnection.Close();
throw SqlExceptionFactory.CreateSqlException(errorNumber.Value);
}
return(result);
}
public async Task <RelationalDataReader> ExecuteReaderAsync(
IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues,
CancellationToken cancellationToken = new CancellationToken())
{
var errorNumber = PreExecution(connection);
var result = await _realRelationalCommand.ExecuteReaderAsync(connection, parameterValues, cancellationToken);
if (errorNumber.HasValue)
{
connection.DbConnection.Close();
result.Dispose(); // Normally, in non-test case, reader is disposed by using in caller code
throw SqlExceptionFactory.CreateSqlException(errorNumber.Value);
}
return(result);
}
public async Task <object> ExecuteScalarAsync(
IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> logger,
CancellationToken cancellationToken = new CancellationToken())
{
var errorNumber = PreExecution(connection);
var result = await _realRelationalCommand.ExecuteScalarAsync(connection, parameterValues, logger, cancellationToken);
if (errorNumber.HasValue)
{
connection.DbConnection.Close();
throw SqlExceptionFactory.CreateSqlException(errorNumber.Value);
}
return(result);
}
public object ExecuteScalar(
IRelationalConnection connection,
IReadOnlyDictionary <string, object> parameterValues,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> logger)
{
var errorNumber = PreExecution(connection);
var result = _realRelationalCommand.ExecuteScalar(connection, parameterValues, logger);
if (errorNumber.HasValue)
{
connection.DbConnection.Close();
throw SqlExceptionFactory.CreateSqlException(errorNumber.Value);
}
return(result);
}
private void PreOpen()
{
if (DbConnection.State == ConnectionState.Open)
{
return;
}
OpenCount++;
if (OpenFailures.Count <= 0)
{
return;
}
var fail = OpenFailures.Dequeue();
if (fail.HasValue)
{
throw SqlExceptionFactory.CreateSqlException(ErrorNumber);
}
}
private int?PreExecution(IRelationalConnection connection)
{
int?errorNumber = null;
var testConnection = (TestSqlServerConnection)connection;
testConnection.ExecutionCount++;
if (testConnection.ExecutionFailures.Count > 0)
{
var fail = testConnection.ExecutionFailures.Dequeue();
if (fail.HasValue)
{
if (fail.Value)
{
testConnection.DbConnection.Close();
throw SqlExceptionFactory.CreateSqlException(testConnection.ErrorNumber);
}
errorNumber = testConnection.ErrorNumber;
}
}
return(errorNumber);
}
public override void Commit()
{
if (_testConnection.CommitFailures.Count > 0)
{
var fail = _testConnection.CommitFailures.Dequeue();
if (fail.HasValue)
{
if (fail.Value)
{
this.GetDbTransaction().Rollback();
}
else
{
this.GetDbTransaction().Commit();
}
_testConnection.DbConnection.Close();
throw SqlExceptionFactory.CreateSqlException(_testConnection.ErrorNumber, _testConnection.ConnectionId);
}
}
base.Commit();
}
public override async Task CommitAsync(CancellationToken cancellationToken = default)
{
if (_testConnection.CommitFailures.Count > 0)
{
var fail = _testConnection.CommitFailures.Dequeue();
if (fail.HasValue)
{
if (fail.Value)
{
await this.GetDbTransaction().RollbackAsync(cancellationToken);
}
else
{
await this.GetDbTransaction().CommitAsync(cancellationToken);
}
await _testConnection.DbConnection.CloseAsync();
throw SqlExceptionFactory.CreateSqlException(_testConnection.ErrorNumber, _testConnection.ConnectionId);
}
}
await base.CommitAsync(cancellationToken);
}
