protected override object Execute(IRelationalConnection connection, string executeMethod, IReadOnlyDictionary <string, object> parameterValues, bool closeConnection)
{
ThrowIf.Argument.IsNull(connection, nameof(connection));
ThrowIf.Argument.IsNull(executeMethod, nameof(executeMethod));
var dbCommand = CreateCommand(connection, parameterValues);
object result = null;
if (connection.DbConnection.State != ConnectionState.Open)
{
connection.Open();
}
if (executeMethod.Equals(nameof(ExecuteReader)))
{
try
{
result = new MySQLRelationalDataReader(connection, dbCommand, new MySQLDataReader(((MySqlCommand)dbCommand).ExecuteReader() as MySqlDataReader));
return(result);
}
catch
{
dbCommand.Dispose();
throw;
}
}
return(base.Execute(connection, executeMethod, parameterValues, closeConnection));
}
public virtual int Execute(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var rowsAffected = 0;
connection.Open();
IDbContextTransaction startedTransaction = null;
try
{
if (connection.CurrentTransaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
commandbatch.Execute(connection);
rowsAffected += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return(rowsAffected);
}
public virtual object Execute(
IRelationalConnection connection,
Func <object> action)
{
Check.NotNull(connection, nameof(connection));
// TODO Deal with suppressing transactions etc.
var connectionWasOpen = connection.DbConnection.State == ConnectionState.Open;
if (!connectionWasOpen)
{
Logger.OpeningConnection(connection.ConnectionString);
connection.Open();
}
try
{
return(action());
}
finally
{
if (!connectionWasOpen)
{
Logger.ClosingConnection(connection.ConnectionString);
connection.Close();
}
}
}
protected override void OpenConnection(IRelationalConnection connection)
{
connection.Open();
((SqliteConnection)connection.DbConnection).EnableExtensions();
SpatialiteLoader.TryLoad(connection.DbConnection);
}
public virtual IReadOnlyList <HistoryRow> GetAppliedMigrations()
{
var rows = new List <HistoryRow>();
if (Exists())
{
_connection.Open();
try
{
using (var reader = _executor.ExecuteReader(_connection, GetAppliedMigrationsSql))
{
while (reader.Read())
{
rows.Add(new HistoryRow(reader.GetString(0), reader.GetString(1)));
}
}
}
finally
{
_connection.Close();
}
}
return(rows);
}
public virtual int Execute(
IEnumerable<ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var rowsAffected = 0;
connection.Open();
IRelationalTransaction startedTransaction = null;
try
{
if (connection.Transaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
commandbatch.Execute(connection);
rowsAffected += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return rowsAffected;
}
/// <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 virtual void ExecuteNonQuery(
IEnumerable <MigrationCommand> migrationCommands,
IRelationalConnection connection)
{
Check.NotNull(migrationCommands, nameof(migrationCommands));
Check.NotNull(connection, nameof(connection));
var userTransaction = connection.CurrentTransaction;
if (userTransaction is not null && migrationCommands.Any(x => x.TransactionSuppressed))
{
throw new NotSupportedException(RelationalStrings.TransactionSuppressedMigrationInUserTransaction);
}
using (new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
{
connection.Open();
try
{
IDbContextTransaction?transaction = null;
try
{
foreach (var command in migrationCommands)
{
if (transaction == null &&
!command.TransactionSuppressed &&
userTransaction is null)
{
transaction = connection.BeginTransaction();
}
if (transaction != null &&
command.TransactionSuppressed)
{
transaction.Commit();
transaction.Dispose();
transaction = null;
}
command.ExecuteNonQuery(connection);
}
transaction?.Commit();
}
finally
{
transaction?.Dispose();
}
}
finally
{
connection.Close();
}
}
}
/// <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 virtual void ExecuteNonQuery(
IEnumerable <MigrationCommand> migrationCommands,
IRelationalConnection connection)
{
Check.NotNull(migrationCommands, nameof(migrationCommands));
Check.NotNull(connection, nameof(connection));
using (new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
{
connection.Open();
try
{
IDbContextTransaction transaction = null;
try
{
foreach (var command in migrationCommands)
{
if (transaction == null &&
!command.TransactionSuppressed)
{
transaction = connection.BeginTransaction();
}
if (transaction != null &&
command.TransactionSuppressed)
{
transaction.Commit();
transaction.Dispose();
transaction = null;
}
command.ExecuteNonQuery(connection);
}
transaction?.Commit();
}
finally
{
transaction?.Dispose();
}
}
finally
{
connection.Close();
}
}
}
public void ExecuteNonQuery(IEnumerable <MigrationCommand> migrationCommands, IRelationalConnection connection)
{
connection.Open();
try
{
foreach (var command in migrationCommands)
{
command.ExecuteNonQuery(connection);
}
}
finally
{
connection.Close();
}
}
public override bool Exists()
{
try
{
return(_relationalConnection.Open());
}
catch (Exception)
{
return(false);
}
finally
{
_relationalConnection.Close();
}
}
public async Task ExecuteNonQueryAsync(IEnumerable <MigrationCommand> migrationCommands, IRelationalConnection connection, CancellationToken cancellationToken = default)
{
connection.Open();
try
{
foreach (var command in migrationCommands)
{
await command.ExecuteNonQueryAsync(connection);
}
}
finally
{
connection.Close();
}
}
/// <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>
public virtual int Execute(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var rowsAffected = 0;
connection.Open();
IDbContextTransaction startedTransaction = null;
try
{
if (connection.CurrentTransaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
commandbatch.Execute(connection);
// Fixed Issue #1: DataReader conflicted when added multiple entities
try
{
lock (this)
{
var reader = (connection.DbConnection as MySqlConnection).Reader.LastOrDefault();
if (reader != null)
{
reader.Dispose();
(connection.DbConnection as MySqlConnection).Reader.Remove(reader);
}
}
}
catch
{
}
rowsAffected += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return(rowsAffected);
}
/// <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>
public virtual void ExecuteNonQuery(
IEnumerable<MigrationCommand> migrationCommands,
IRelationalConnection connection)
{
Check.NotNull(migrationCommands, nameof(migrationCommands));
Check.NotNull(connection, nameof(connection));
connection.Open();
try
{
IDbContextTransaction transaction = null;
try
{
foreach (var command in migrationCommands)
{
if (transaction == null
&& !command.TransactionSuppressed)
{
transaction = connection.BeginTransaction();
}
if (transaction != null
&& command.TransactionSuppressed)
{
transaction.Commit();
transaction.Dispose();
transaction = null;
}
command.ExecuteNonQuery(connection);
}
transaction?.Commit();
}
finally
{
transaction?.Dispose();
}
}
finally
{
connection.Close();
}
}
public int Execute(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var registrosAfetados = 0;
connection.Open();
IDbContextTransaction startedTransaction = null;
try
{
if (connection.CurrentTransaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
commandbatch.Execute(connection);
registrosAfetados += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
startedTransaction?.Dispose();
}
catch (Exception ex)
{
ex.Message.ToString();
try
{
startedTransaction?.Rollback();
startedTransaction?.Dispose();
}
catch
{
// if the connection was lost, rollback command will fail. prefer to throw original exception in that case
}
throw;
}
finally
{
connection.Close();
}
return(registrosAfetados);
}
/// <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>
public virtual int Execute(
IEnumerable<ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var rowsAffected = 0;
connection.Open();
IDbContextTransaction startedTransaction = null;
try
{
if (connection.CurrentTransaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
commandbatch.Execute(connection);
// Fixed Issue #1: DataReader conflicted when added multiple entities
try
{
lock (this)
{
var reader = (connection.DbConnection as MySqlConnection).Reader.LastOrDefault();
if (reader != null)
{
reader.Dispose();
(connection.DbConnection as MySqlConnection).Reader.Remove(reader);
}
}
}
catch
{
}
rowsAffected += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return rowsAffected;
}
public int Execute(IEnumerable <ModificationCommandBatch> commandBatches, IRelationalConnection connection)
{
var recordAffecteds = 0;
if (connection?.DbConnection?.State != System.Data.ConnectionState.Open)
{
connection.Open();
}
IDbContextTransaction currentTransaction = null;
try
{
if (connection.CurrentTransaction == null)
{
currentTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
commandbatch.Execute(connection);
recordAffecteds += commandbatch.ModificationCommands.Count;
}
currentTransaction?.Commit();
currentTransaction?.Dispose();
}
catch (Exception ex)
{
try
{
currentTransaction?.Rollback();
currentTransaction?.Dispose();
}
catch
{
//
}
throw ex;
}
finally
{
connection?.Close();
}
return(recordAffecteds);
}
protected virtual object Execute(
IRelationalConnection connection,
Func <object> action)
{
Check.NotNull(connection, nameof(connection));
// TODO Deal with suppressing transactions etc.
connection.Open();
try
{
return(action());
}
finally
{
connection.Close();
}
}
/// <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 virtual int Execute(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var rowsAffected = 0;
IDbContextTransaction startedTransaction = null;
try
{
if (connection.CurrentTransaction == null &&
(connection as ITransactionEnlistmentManager)?.EnlistedTransaction == null &&
Transaction.Current == null &&
CurrentContext.Context.Database.AutoTransactionsEnabled)
{
startedTransaction = connection.BeginTransaction();
}
else
{
connection.Open();
}
foreach (var batch in commandBatches)
{
batch.Execute(connection);
rowsAffected += batch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
if (startedTransaction != null)
{
startedTransaction.Dispose();
}
else
{
connection.Close();
}
}
return(rowsAffected);
}
/// <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 virtual int Execute(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var rowsAffected = 0;
var transaction = connection.CurrentTransaction;
var beganTransaction = false;
var createdSavepoint = false;
try
{
var transactionEnlistManager = connection as ITransactionEnlistmentManager;
if (transaction == null &&
transactionEnlistManager?.EnlistedTransaction is null &&
transactionEnlistManager?.CurrentAmbientTransaction is null &&
CurrentContext.Context.Database.AutoTransactionsEnabled)
{
transaction = connection.BeginTransaction();
beganTransaction = true;
}
else
{
connection.Open();
if (transaction?.SupportsSavepoints == true &&
CurrentContext.Context.Database.AutoSavepointsEnabled)
{
transaction.CreateSavepoint(SavepointName);
createdSavepoint = true;
}
}
foreach (var batch in commandBatches)
{
batch.Execute(connection);
rowsAffected += batch.ModificationCommands.Count;
}
if (beganTransaction)
{
transaction.Commit();
}
}
protected virtual T Execute <T>(
[NotNull] IRelationalConnection connection,
[NotNull] RelationalCommand command,
[NotNull] Func <DbCommand, T> action)
{
// TODO Deal with suppressing transactions etc.
connection.Open();
try
{
using (var dbCommand = command.CreateCommand(connection))
{
Logger.LogCommand(dbCommand);
return(action(dbCommand));
}
}
finally
{
connection.Close();
}
}
public virtual int Execute(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
Check.NotNull(commandBatches, nameof(commandBatches));
Check.NotNull(connection, nameof(connection));
var rowsAffected = 0;
connection.Open();
IRelationalTransaction startedTransaction = null;
try
{
if (connection.Transaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
commandbatch.Execute(
connection.Transaction,
_typeMapper,
_context,
Logger);
rowsAffected += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return(rowsAffected);
}
public static void ExecuteNonQuery(
[NotNull] this IEnumerable <IRelationalCommand> commands,
[NotNull] IRelationalConnection connection)
{
Check.NotNull(commands, nameof(commands));
Check.NotNull(connection, nameof(connection));
connection.Open();
try
{
foreach (var command in commands)
{
command.ExecuteNonQuery(
connection,
manageConnection: false);
}
}
finally
{
connection.Close();
}
}
public virtual int Execute(
IEnumerable<ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
Check.NotNull(commandBatches, nameof(commandBatches));
Check.NotNull(connection, nameof(connection));
var rowsAffected = 0;
connection.Open();
RelationalTransaction startedTransaction = null;
try
{
if (connection.Transaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
rowsAffected += commandbatch.Execute(
connection.Transaction,
_typeMapper,
_context,
Logger);
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return rowsAffected;
}
public virtual void ExecuteNonQuery(
IRelationalConnection connection,
IEnumerable <RelationalCommand> relationalCommands)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(relationalCommands, nameof(relationalCommands));
connection.Open();
try
{
foreach (var command in relationalCommands)
{
Execute <object>(
connection,
command,
c => c.ExecuteNonQuery());
}
}
finally
{
connection.Close();
}
}
protected virtual void OpenConnection(IRelationalConnection connection) => connection.Open();
/// <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 virtual int Execute(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var rowsAffected = 0;
var transaction = connection.CurrentTransaction;
var beganTransaction = false;
var createdSavepoint = false;
try
{
if (transaction == null &&
(connection as ITransactionEnlistmentManager)?.EnlistedTransaction == null &&
Transaction.Current == null &&
CurrentContext.Context.Database.AutoTransactionsEnabled)
{
transaction = connection.BeginTransaction();
beganTransaction = true;
}
else
{
connection.Open();
if (transaction?.SupportsSavepoints == true &&
CurrentContext.Context.Database.AutoSavepointsEnabled)
{
transaction.CreateSavepoint(SavepointName);
createdSavepoint = true;
}
}
foreach (var batch in commandBatches)
{
batch.Execute(connection);
rowsAffected += batch.ModificationCommands.Count;
}
if (beganTransaction)
{
transaction.Commit();
}
}
catch
{
if (createdSavepoint && connection.DbConnection.State == ConnectionState.Open)
{
try
{
transaction.RollbackToSavepoint(SavepointName);
}
catch (Exception e)
{
UpdateLogger.BatchExecutorFailedToRollbackToSavepoint(CurrentContext.GetType(), e);
}
}
throw;
}
finally
{
if (beganTransaction)
{
transaction.Dispose();
}
else
{
if (createdSavepoint)
{
if (connection.DbConnection.State == ConnectionState.Open)
{
try
{
transaction.ReleaseSavepoint(SavepointName);
}
catch (Exception e)
{
UpdateLogger.BatchExecutorFailedToReleaseSavepoint(CurrentContext.GetType(), e);
}
}
}
connection.Close();
}
}
return(rowsAffected);
}
// TODO: Copy and paste base code again in 3.0.
// Then replace "RelationalDataReader" with "MySqlConverterRelationalDataReader".
// TODO: Remove entire method in 3.1.
// Replace with overridden implementation of "CreateRelationalDataReader".
/// <summary>
/// Uses the same code as in it's base class, except for returning a
/// ConverterRelationalDataReader instead of a RelationalDataReader.
/// </summary>
protected override object Execute(
IRelationalConnection connection,
DbCommandMethod executeMethod,
IReadOnlyDictionary <string, object> parameterValues)
{
if (connection == null)
{
throw new ArgumentNullException(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 MySqlConverterRelationalDataReader(
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.Parameters.Clear();
dbCommand.Dispose();
connection.Close();
}
}
return(result);
}
/// <summary>
/// The method called by other methods on this type to execute synchronously.
/// </summary>
/// <param name="connection"> The connection to use. </param>
/// <param name="executeMethod"> The method type. </param>
/// <param name="parameterValues"> The parameter values. </param>
/// <param name="logger"> The command logger. </param>
/// <returns> The result of the execution. </returns>
protected virtual object Execute(
[NotNull] IRelationalConnection connection,
DbCommandMethod executeMethod,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues,
[CanBeNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> logger)
{
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,
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.Parameters.Clear();
dbCommand.Dispose();
connection.Close();
}
}
return(result);
}
public override void Create()
{
_connection.Open();
_connection.Close();
}
protected virtual object Execute(
[NotNull] IRelationalConnection connection,
[NotNull] string executeMethod,
bool openConnection,
bool closeConnection,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues = null)
{
var dbCommand = CreateCommand(connection, parameterValues);
WriteDiagnostic(
RelationalDiagnostics.BeforeExecuteCommand,
dbCommand,
executeMethod);
object result;
if (openConnection)
{
connection.Open();
}
Stopwatch stopwatch = null;
try
{
if (Logger.IsEnabled(LogLevel.Information))
{
stopwatch = Stopwatch.StartNew();
}
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(
openConnection ? connection : null,
dbCommand,
dbCommand.ExecuteReader());
}
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: false,
exception: exception);
if (openConnection && !closeConnection)
{
connection.Close();
}
throw;
}
finally
{
if (closeConnection)
{
connection.Close();
}
}
WriteDiagnostic(
RelationalDiagnostics.AfterExecuteCommand,
dbCommand,
executeMethod);
return(result);
}
public virtual object Execute(
IRelationalConnection connection,
Func<object> action)
{
Check.NotNull(connection, nameof(connection));
// TODO Deal with suppressing transactions etc.
var connectionWasOpen = connection.DbConnection.State == ConnectionState.Open;
if (!connectionWasOpen)
{
Logger.OpeningConnection(connection.ConnectionString);
connection.Open();
}
try
{
return action();
}
finally
{
if (!connectionWasOpen)
{
Logger.ClosingConnection(connection.ConnectionString);
connection.Close();
}
}
}
protected override void OpenConnection(IRelationalConnection connection)
{
connection.Open();
SpatialiteLoader.TryLoad(connection.DbConnection);
}
private async Task <object> ExecuteAsync(
IOBehavior ioBehavior,
[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)
{
if (ioBehavior == IOBehavior.Asynchronous)
{
await connection.OpenAsync(cancellationToken).ConfigureAwait(false);
}
else
{
connection.Open();
}
}
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(openConnection ? connection : null, dbCommand,
new SynchronizedMySqlDataReader(dataReader, mySqlConnection));
}
catch (Exception)
{
dbCommand.Dispose();
throw;
}
break;
}
default:
{
throw new NotSupportedException();
}
}
}
catch (Exception)
{
if (openConnection && !closeConnection)
{
connection.Close();
}
throw;
}
finally
{
if (closeConnection)
{
connection.Close();
}
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();
}
}
return(result);
}
protected virtual object Execute(
IRelationalConnection connection,
Func<object> action)
{
Check.NotNull(connection, nameof(connection));
// TODO Deal with suppressing transactions etc.
connection.Open();
try
{
return action();
}
finally
{
connection.Close();
}
}
/// <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(
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());
}
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);
if (closeConnection)
{
connection.Close();
}
}
catch (Exception exception)
{
var currentTimestamp = Stopwatch.GetTimestamp();
Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp);
DiagnosticSource.WriteCommandError(
dbCommand,
executeMethod,
instanceId,
startTimestamp,
currentTimestamp,
exception,
async: false);
connection.Close();
throw;
}
finally
{
dbCommand.Parameters.Clear();
}
return(result);
}
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);
}
