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