public Migrator(
[NotNull] IMigrationsAssembly migrationAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IMigrationsSqlGenerator sqlGenerator,
[NotNull] ISqlStatementExecutor executor,
[NotNull] IRelationalConnection connection,
[NotNull] IUpdateSqlGenerator sql,
[NotNull] ILoggerFactory loggerFactory)
{
Check.NotNull(migrationAssembly, nameof(migrationAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
Check.NotNull(executor, nameof(executor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(sql, nameof(sql));
Check.NotNull(loggerFactory, nameof(loggerFactory));
_migrationAssembly = migrationAssembly;
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_sqlGenerator = sqlGenerator;
_executor = executor;
_connection = connection;
_sql = sql;
_logger = new LazyRef<ILogger>(loggerFactory.CreateLogger<Migrator>);
}
public Migrator(
[NotNull] MigrationAssembly migrationAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDataStoreCreator dataStoreCreator,
[NotNull] IMigrationSqlGenerator migrationSqlGenerator,
[NotNull] SqlStatementExecutor executor,
[NotNull] IRelationalConnection connection,
[NotNull] IModelDiffer modelDiffer,
[NotNull] IModel model,
[NotNull] MigrationIdGenerator idGenerator,
[NotNull] ISqlGenerator sqlGenerator)
{
Check.NotNull(migrationAssembly, nameof(migrationAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(dataStoreCreator, nameof(dataStoreCreator));
Check.NotNull(migrationSqlGenerator, nameof(migrationSqlGenerator));
Check.NotNull(executor, nameof(executor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(model, nameof(model));
Check.NotNull(idGenerator, nameof(idGenerator));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
_migrationAssembly = migrationAssembly;
_historyRepository = historyRepository;
_dataStoreCreator = (IRelationalDataStoreCreator)dataStoreCreator;
_migrationSqlGenerator = migrationSqlGenerator;
_executor = executor;
_connection = connection;
_modelDiffer = modelDiffer;
_model = model;
_idGenerator = idGenerator;
_sqlGenerator = sqlGenerator;
}
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 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 Migrator(
[NotNull] IMigrationsAssembly migrationsAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IRelationalConnection connection,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] ILogger<Migrator> logger,
[NotNull] IDatabaseProviderServices providerServices)
{
Check.NotNull(migrationsAssembly, nameof(migrationsAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(migrationCommandExecutor, nameof(migrationCommandExecutor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(logger, nameof(logger));
Check.NotNull(providerServices, nameof(providerServices));
_migrationsAssembly = migrationsAssembly;
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_migrationCommandExecutor = migrationCommandExecutor;
_connection = connection;
_sqlGenerationHelper = sqlGenerationHelper;
_logger = logger;
_activeProvider = providerServices.InvariantName;
}
public virtual async Task<int> ExecuteAsync(
IEnumerable<ModificationCommandBatch> commandBatches,
IRelationalConnection connection,
CancellationToken cancellationToken = default(CancellationToken))
{
var rowsAffected = 0;
await connection.OpenAsync(cancellationToken);
IRelationalTransaction startedTransaction = null;
try
{
if (connection.Transaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
await commandbatch.ExecuteAsync(connection, cancellationToken);
rowsAffected += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return rowsAffected;
}
public RelationalQueryContextFactory(
[NotNull] IStateManager stateManager,
[NotNull] IKeyValueFactorySource keyValueFactorySource,
[NotNull] IRelationalConnection connection)
: base(stateManager, keyValueFactorySource)
{
_connection = connection;
}
public RelationalSqlExecutor(
[NotNull] ISqlStatementExecutor statementExecutor,
[NotNull] IRelationalConnection connection,
[NotNull] IRelationalTypeMapper typeMapper)
{
_statementExecutor = statementExecutor;
_connection = connection;
_typeMapper = typeMapper;
}
public RelationalQueryContextFactory(
[NotNull] IStateManager stateManager,
[NotNull] IConcurrencyDetector concurrencyDetector,
[NotNull] IRelationalConnection connection,
[NotNull] IChangeDetector changeDetector)
: base(stateManager, concurrencyDetector, changeDetector)
{
_connection = connection;
}
public ConcreteRelationalDatabase(
DbContext context,
IRelationalDataStoreCreator dataStoreCreator,
IRelationalConnection connection,
Migrator migrator,
ILoggerFactory loggerFactory)
: base(context, dataStoreCreator, connection, migrator, loggerFactory)
{
}
public virtual object ExecuteScalar(
IRelationalConnection connection,
IReadOnlyDictionary<string, object> parameterValues = null,
bool manageConnection = true)
=> Execute(
Check.NotNull(connection, nameof(connection)),
nameof(ExecuteScalar),
parameterValues,
openConnection: manageConnection,
closeConnection: manageConnection);
public MyRelationalDatabase(IQueryCompilationContextFactory queryCompilationContextFactory,
ICommandBatchPreparer batchPreparer,
IBatchExecutor batchExecutor,
IRelationalConnection connection)
: base(queryCompilationContextFactory,
batchPreparer,
batchExecutor,
connection)
{
}
public RelationalSqlExecutor(
[NotNull] ISqlCommandBuilder sqlCommandBuilder,
[NotNull] IRelationalConnection connection)
{
Check.NotNull(sqlCommandBuilder, nameof(sqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
_sqlCommandBuilder = sqlCommandBuilder;
_connection = connection;
}
public RelationalQueryContextFactory(
[NotNull] IStateManager stateManager,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IClrCollectionAccessorSource collectionAccessorSource,
[NotNull] IClrAccessorSource<IClrPropertySetter> propertySetterSource,
[NotNull] IRelationalConnection connection)
: base(stateManager, entityKeyFactorySource, collectionAccessorSource, propertySetterSource)
{
_connection = connection;
}
public FakeRelationalDataStore(
IModel model,
IEntityKeyFactorySource entityKeyFactorySource,
IEntityMaterializerSource entityMaterializerSource,
IRelationalConnection connection,
CommandBatchPreparer batchPreparer,
BatchExecutor batchExecutor,
IDbContextOptions options,
ILoggerFactory loggerFactory)
: base(model, entityKeyFactorySource, entityMaterializerSource, connection, batchPreparer, batchExecutor, options, loggerFactory)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RelationalDataReader"/> class.
/// </summary>
/// <param name="connection"> The connection. </param>
/// <param name="command"> The command that was executed. </param>
/// <param name="reader"> The underlying reader for the result set. </param>
public RelationalDataReader(
[CanBeNull] IRelationalConnection connection,
[NotNull] DbCommand command,
[NotNull] DbDataReader reader)
{
Check.NotNull(command, nameof(command));
Check.NotNull(reader, nameof(reader));
_connection = connection;
_command = command;
_reader = reader;
}
public virtual Task<object> ExecuteScalarAsync(
IRelationalConnection connection,
IReadOnlyDictionary<string, object> parameterValues = null,
bool manageConnection = true,
CancellationToken cancellationToken = default(CancellationToken))
=> ExecuteAsync(
Check.NotNull(connection, nameof(connection)),
nameof(ExecuteScalar),
parameterValues,
openConnection: manageConnection,
closeConnection: manageConnection,
cancellationToken: cancellationToken);
public RelationalQueryContextFactory(
[NotNull] IStateManager stateManager,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IClrCollectionAccessorSource collectionAccessorSource,
[NotNull] IClrAccessorSource<IClrPropertySetter> propertySetterSource,
[NotNull] IRelationalConnection connection,
[NotNull] ILoggerFactory loggerFactory)
: base(stateManager, entityKeyFactorySource, collectionAccessorSource, propertySetterSource, loggerFactory)
{
Check.NotNull(connection, nameof(connection));
_connection = connection;
}
public SqliteHistoryRepository(
[NotNull] IRelationalConnection connection,
[NotNull] DbContext context,
[NotNull] SqliteUpdateSqlGenerator sql)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(context, nameof(context));
Check.NotNull(sql, nameof(sql));
_connection = connection;
_contextKey = context.GetType().FullName;
_sql = sql;
}
public RelationalDatabase(
[NotNull] IQueryCompilationContextFactory queryCompilationContextFactory,
[NotNull] ICommandBatchPreparer batchPreparer,
[NotNull] IBatchExecutor batchExecutor,
[NotNull] IRelationalConnection connection)
: base(queryCompilationContextFactory)
{
Check.NotNull(batchPreparer, nameof(batchPreparer));
Check.NotNull(batchExecutor, nameof(batchExecutor));
Check.NotNull(connection, nameof(connection));
_batchPreparer = batchPreparer;
_batchExecutor = batchExecutor;
_connection = connection;
}
public HistoryRepository(
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] ISqlStatementExecutor executor,
[NotNull] IRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRelationalAnnotationProvider annotations,
[NotNull] ISqlGenerator sqlGenerator)
{
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(executor, nameof(executor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(annotations, nameof(annotations));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_executor = executor;
_connection = connection;
_modelDiffer = modelDiffer;
_migrationsSqlGenerator = migrationsSqlGenerator;
SqlGenerator = sqlGenerator;
var relationalOptions = RelationalOptionsExtension.Extract(options);
TableName = relationalOptions?.MigrationsHistoryTableName ?? DefaultTableName;
TableSchema = relationalOptions.MigrationsHistoryTableSchema;
_model = new LazyRef<IModel>(
() =>
{
var modelBuilder = new ModelBuilder(new ConventionSet());
modelBuilder.Entity<HistoryRow>(
x =>
{
ConfigureTable(x);
x.ToTable(TableName, TableSchema);
});
return modelBuilder.Model;
});
var entityType = new LazyRef<IEntityType>(() => _model.Value.GetEntityType(typeof(HistoryRow)));
_migrationIdColumnName = new LazyRef<string>(
() => annotations.For(entityType.Value.FindProperty(nameof(HistoryRow.MigrationId))).ColumnName);
_productVersionColumnName = new LazyRef<string>(
() => annotations.For(entityType.Value.FindProperty(nameof(HistoryRow.ProductVersion))).ColumnName);
}
public SqliteDataStoreCreator(
[NotNull] IRelationalConnection connection,
[NotNull] IModelDiffer modelDiffer,
[NotNull] IMigrationSqlGenerator migrationSqlGenerator,
[NotNull] ISqlStatementExecutor sqlStatementExecutor)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationSqlGenerator, nameof(migrationSqlGenerator));
Check.NotNull(sqlStatementExecutor, nameof(sqlStatementExecutor));
_connection = connection;
_modelDiffer = modelDiffer;
_migrationSqlGenerator = migrationSqlGenerator;
_executor = sqlStatementExecutor;
}
/// <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 async Task<int> ExecuteAsync(
IEnumerable<ModificationCommandBatch> commandBatches,
IRelationalConnection connection,
CancellationToken cancellationToken = default(CancellationToken))
{
var rowsAffected = 0;
await connection.OpenAsync(cancellationToken);
IDbContextTransaction startedTransaction = null;
try
{
if (connection.CurrentTransaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
await commandbatch.ExecuteAsync(connection, cancellationToken);
// 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 async Task ExecuteNonQueryAsync(
IEnumerable<MigrationCommand> migrationCommands,
IRelationalConnection connection,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(migrationCommands, nameof(migrationCommands));
Check.NotNull(connection, nameof(connection));
await connection.OpenAsync(cancellationToken);
try
{
IDbContextTransaction transaction = null;
try
{
foreach (var command in migrationCommands)
{
if (transaction == null
&& !command.TransactionSuppressed)
{
transaction = await connection.BeginTransactionAsync(cancellationToken);
}
if (transaction != null
&& command.TransactionSuppressed)
{
transaction.Commit();
transaction.Dispose();
transaction = null;
}
await command.ExecuteNonQueryAsync(connection, cancellationToken: cancellationToken);
}
transaction?.Commit();
}
finally
{
transaction?.Dispose();
}
}
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 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();
}
}
/// <summary>
/// Creates a new instance of <see cref="DataMigrator"/>.
/// </summary>
public DataMigrator(
IHistoryRepository historyRepository,
IDatabaseCreator databaseCreator,
IMigrationsSqlGenerator migrationsSqlGenerator,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IRelationalConnection connection,
ILoggerFactory loggerFactory,
IServiceProvider serviceProvider)
{
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_connection = connection;
_serviceProvider = serviceProvider;
_logger = loggerFactory.CreateLogger<DataMigrator>();
}
protected virtual async Task<object> ExecuteAsync(
IRelationalConnection connection,
Func<Task<object>> action,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(connection, nameof(connection));
await connection.OpenAsync(cancellationToken);
try
{
return await action();
}
finally
{
connection.Close();
}
}
public RelationalSqlExecutor(
[NotNull] IRelationalCommandBuilderFactory relationalCommandBuilderFactory,
[NotNull] IParameterNameGeneratorFactory parameterNameGeneratorFactory,
[NotNull] ISqlStatementExecutor statementExecutor,
[NotNull] IRelationalConnection connection,
[NotNull] IRelationalTypeMapper typeMapper)
{
Check.NotNull(relationalCommandBuilderFactory, nameof(relationalCommandBuilderFactory));
Check.NotNull(parameterNameGeneratorFactory, nameof(parameterNameGeneratorFactory));
Check.NotNull(statementExecutor, nameof(statementExecutor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(typeMapper, nameof(typeMapper));
_relationalCommandBuilderFactory = relationalCommandBuilderFactory;
_parameterNameGeneratorFactory = parameterNameGeneratorFactory;
_statementExecutor = statementExecutor;
_connection = connection;
}
public RelationalDatabaseFactory(
[NotNull] DbContext context,
[NotNull] IRelationalDataStoreCreator dataStoreCreator,
[NotNull] IRelationalConnection connection,
[NotNull] IMigrator migrator,
[NotNull] ILoggerFactory loggerFactory)
{
Check.NotNull(context, nameof(context));
Check.NotNull(dataStoreCreator, nameof(dataStoreCreator));
Check.NotNull(connection, nameof(connection));
Check.NotNull(migrator, nameof(migrator));
Check.NotNull(loggerFactory, nameof(loggerFactory));
_context = context;
_dataStoreCreator = dataStoreCreator;
_connection = connection;
_migrator = migrator;
_loggerFactory = loggerFactory;
}
public virtual Task<object> ExecuteScalarAsync(
IRelationalConnection connection,
DbTransaction transaction,
string sql,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(sql, nameof(sql));
return ExecuteAsync(
connection,
() =>
{
var command = new SqlBatch(sql).CreateCommand(connection, transaction);
Logger.LogCommand(command);
return command.ExecuteScalarAsync(cancellationToken);
},
cancellationToken);
}
public MyHistoryRepository(
IDatabaseCreator databaseCreator,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IRelationalConnection connection,
IDbContextOptions options,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator migrationsSqlGenerator,
IRelationalAnnotationProvider annotations,
ISqlGenerationHelper sqlGenerationHelper)
: base(databaseCreator,
rawSqlCommandBuilder,
connection,
options,
modelDiffer,
migrationsSqlGenerator,
annotations,
sqlGenerationHelper
)
{
}
Task <RelationalDataReader> IRelationalCommand.ExecuteReaderAsync(
IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues, bool manageConnection, CancellationToken cancellationToken)
=> ExecuteReaderAsync(connection, parameterValues, cancellationToken);
RelationalDataReader IRelationalCommand.ExecuteReader(
IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues, bool manageConnection)
=> ExecuteReader(connection, parameterValues);
protected override object Execute(IRelationalConnection connection, DbCommandMethod executeMethod, IReadOnlyDictionary <string, object> parameterValues)
{
return(ExecuteAsync(connection, executeMethod, parameterValues)
.GetAwaiter()
.GetResult());
}
/// <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 override Task <object> ExecuteScalarAsync(
IRelationalConnection connection,
string sql,
CancellationToken cancellationToken = new CancellationToken())
=> Task.FromResult <object>(Interlocked.Add(ref _current, _blockSize));
protected override void OpenConnection(IRelationalConnection connection)
{
connection.Open();
SpatialiteLoader.TryLoad(connection.DbConnection);
}
public object ExecuteScalar(
IRelationalConnection connection,
IReadOnlyDictionary <string, object> parameterValues,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> logger)
=> Interlocked.Add(ref _commandBuilder._current, _commandBuilder._blockSize);
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;
var isReader = false;
var startTimestamp = Stopwatch.GetTimestamp();
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):
{
if (ioBehavior == IOBehavior.Asynchronous)
{
result = await dbCommand.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
}
else
{
result = dbCommand.ExecuteNonQuery();
}
break;
}
case nameof(ExecuteScalar):
{
if (ioBehavior == IOBehavior.Asynchronous)
{
result = await dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false);
}
else
{
result = dbCommand.ExecuteScalar();
}
break;
}
case nameof(ExecuteReader):
{
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));
isReader = true;
break;
}
default:
{
throw new NotSupportedException();
}
}
}
finally
{
var currentTimestamp = Stopwatch.GetTimestamp();
Logger.LogCommandExecuted(dbCommand, startTimestamp, currentTimestamp);
if (!isReader)
{
// NonQuery, Scalar, and Exceptions can be disposed, and should release locks
dbCommand.Dispose();
if (locked)
{
mySqlConnection.Lock.Release();
mySqlConnection.PoolingClose();
}
}
// ReSharper disable once PossibleNullReferenceException
if (!mySqlConnection.Pooling && closeConnection)
{
connection.Close();
}
}
return(result);
}
public override object ExecuteScalar(IRelationalConnection connection, string sql) => Interlocked.Add(ref _current, _blockSize);
private DbCommand CreateCommand(
IRelationalConnection connection,
IReadOnlyDictionary <string, object> parameterValues)
{
var command = connection.DbConnection.CreateCommand();
command.CommandText = CommandText;
if (connection.CurrentTransaction != null)
{
command.Transaction = connection.CurrentTransaction.GetDbTransaction();
}
if (connection.CommandTimeout != null)
{
command.CommandTimeout = (int)connection.CommandTimeout;
}
if (Parameters.Count > 0)
{
if (parameterValues == null)
{
throw new InvalidOperationException(RelationalStrings.MissingParameterValue(Parameters[0].InvariantName));
}
foreach (var parameter in Parameters)
{
object parameterValue;
if (parameterValues.TryGetValue(parameter.InvariantName, out parameterValue))
{
if (parameterValue != null)
{
if (parameterValue is char)
{
parameter.AddDbParameter(command, Convert.ToByte((char)parameterValue));
}
else if (parameterValue is DateTimeOffset)
{
parameter.AddDbParameter(command, ((DateTimeOffset)parameterValue).UtcDateTime);
}
else if (parameterValue.GetType().FullName.StartsWith("System.JsonObject"))
{
parameter.AddDbParameter(command, parameterValue.ToString());
}
else
{
parameter.AddDbParameter(command, parameterValue);
}
}
else
{
parameter.AddDbParameter(command, parameterValue);
}
}
else
{
throw new InvalidOperationException(
RelationalStrings.MissingParameterValue(parameter.InvariantName));
}
}
}
return(command);
}
public abstract Task ExecuteAsync(
[NotNull] IRelationalConnection connection,
CancellationToken cancellationToken = default);
public abstract void Execute([NotNull] IRelationalConnection connection);
/// <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,
[NotNull] string executeMethod,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues,
bool closeConnection = true,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(connection, nameof(connection));
Check.NotEmpty(executeMethod, nameof(executeMethod));
var dbCommand = CreateCommand(connection, parameterValues);
await connection.OpenAsync(cancellationToken);
var startTimestamp = Stopwatch.GetTimestamp();
var instanceId = Guid.NewGuid();
DiagnosticSource.WriteCommandBefore(
dbCommand,
executeMethod,
instanceId,
startTimestamp,
async: true);
object result;
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(
connection,
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);
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: true);
connection.Close();
throw;
}
finally
{
dbCommand.Parameters.Clear();
}
return(result);
}
public override void ExecuteNonQuery(IRelationalConnection connection, IEnumerable<RelationalCommand> relationalCommands)
{
}
int IRelationalCommand.ExecuteNonQuery(
IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues, bool manageConnection)
=> ExecuteNonQuery(connection, parameterValues);
public Task <int> ExecuteNonQueryAsync(IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues, CancellationToken cancellationToken = default(CancellationToken)) => Task.FromResult(0);
public Task <object> ExecuteScalarAsync(
IRelationalConnection connection,
IReadOnlyDictionary <string, object> parameterValues,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> logger,
CancellationToken cancellationToken = default)
=> Task.FromResult <object>(Interlocked.Add(ref _commandBuilder._current, _commandBuilder._blockSize));
public Task <object> ExecuteScalarAsync(IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public int ExecuteNonQuery(IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues)
{
return(0);
}
public Task <int> ExecuteNonQueryAsync(
IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> logger,
CancellationToken cancellationToken = default)
=> Task.FromResult(0);
public object ExecuteScalar(IRelationalConnection connection, IReadOnlyDictionary <string, object> parameterValues)
{
throw new NotImplementedException();
}
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);
}
public RelationalTransaction Create(
IRelationalConnection connection,
DbTransaction transaction,
IDiagnosticsLogger <DbLoggerCategory.Database.Transaction> logger,
bool transactionOwned)
=> new TestRelationalTransaction(connection, transaction, logger, transactionOwned);
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);
}
/// <summary>
/// 执行并返回一行一列数据
/// </summary>
/// <param name="connection">连接对象</param>
/// <param name="parameterValues">参数值</param>
/// <returns></returns>
public object ExecuteScalar(
[NotNull] IRelationalConnection connection,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues = null)
{
return(_relationalCommand.ExecuteScalar(Check.NotNull(connection, nameof(connection)), parameterValues));
}
public override Task ExecuteNonQueryAsync(
IRelationalConnection connection,
IEnumerable<RelationalCommand> relationalCommands,
CancellationToken cancellationToken = default(CancellationToken))
=> Task.FromResult(0);
protected virtual void OpenConnection(IRelationalConnection connection) => connection.Open();
/// <summary>
/// Executes the command with a <see cref="RelationalDataReader" /> result.
/// </summary>
/// <param name="command"> The command to be executed. </param>
/// <param name="connection"> The connection to execute against. </param>
/// <returns> The result of the command. </returns>
public static RelationalDataReader ExecuteReader(
[NotNull] this IRelationalCommand command,
[NotNull] IRelationalConnection connection)
=> command.ExecuteReader(connection, parameterValues: null);
/// <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)
=> CurrentContext.Context.Database.AutoTransactionsEnabled
? ExecutionStrategyFactory.Create().Execute((commandBatches, connection), Execute, null)
/// <summary>
/// Asynchronously executes the command with a <see cref="RelationalDataReader" /> result.
/// </summary>
/// <param name="command"> The command to be executed. </param>
/// <param name="connection"> The connection to execute against. </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. The task result contains the result of the command.
/// </returns>
public static Task <RelationalDataReader> ExecuteReaderAsync(
[NotNull] this IRelationalCommand command,
[NotNull] IRelationalConnection connection,
CancellationToken cancellationToken = default(CancellationToken))
=> command.ExecuteReaderAsync(connection, parameterValues: null, cancellationToken: cancellationToken);
