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 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 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; }
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); rowsAffected += commandbatch.ModificationCommands.Count; } startedTransaction?.Commit(); } finally { startedTransaction?.Dispose(); connection.Close(); } return(rowsAffected); }
private void Execute(IEnumerable <RelationalCommand> relationalCommands) { using (var transaction = _connection.BeginTransaction()) { _executor.ExecuteNonQuery(_connection, relationalCommands); transaction.Commit(); } }
/// <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 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 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(); } } }
protected virtual void Execute([NotNull] IEnumerable <SqlBatch> sqlBatches, bool ensureDatabase = false) { Check.NotNull(sqlBatches, nameof(sqlBatches)); if (ensureDatabase && !_dataStoreCreator.Exists()) { _dataStoreCreator.Create(); } using (var transaction = _connection.BeginTransaction()) { _executor.ExecuteNonQuery(_connection, transaction.DbTransaction, sqlBatches); transaction.Commit(); } }
/// <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); }
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); }
/// <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(); } }
/// <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); }
public virtual async Task <int> ExecuteAsync( [NotNull] IEnumerable <ModificationCommandBatch> commandBatches, [NotNull] IRelationalConnection connection, CancellationToken cancellationToken = default(CancellationToken)) { Check.NotNull(commandBatches, nameof(commandBatches)); Check.NotNull(connection, nameof(connection)); var rowsAffected = 0; await connection.OpenAsync(cancellationToken).WithCurrentCulture(); RelationalTransaction startedTransaction = null; try { if (connection.Transaction == null) { startedTransaction = connection.BeginTransaction(); } foreach (var commandbatch in commandBatches) { rowsAffected += await commandbatch.ExecuteAsync( connection.Transaction, _typeMapper, _context, Logger, cancellationToken) .WithCurrentCulture(); } startedTransaction?.Commit(); } finally { startedTransaction?.Dispose(); connection.Close(); } return(rowsAffected); }
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 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; }
/// <summary> /// 执行并返回一行一列的数据 /// </summary> /// <param name="migrationCommands">迁移命令</param> /// <param name="connection">连接对象</param> /// <param name="logger">日志</param> /// <returns></returns> public object ExecuteScalar( IEnumerable <MigrationCommand> migrationCommands, IRelationalConnection connection, IDiagnosticsLogger <DbLoggerCategory.Database> logger = null) { try { if (Check.IsTraceEnabled(logger?.Logger)) { Trace <DbLoggerCategory.Database> .Write(logger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleMigrationCommandExecutor, OracleTraceFuncName.ExecuteScalar); } m_oracleLogger = logger; object result = new object(); Check.NotNull(migrationCommands, nameof(migrationCommands)); Check.NotNull(connection, nameof(connection)); using (new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled)) { connection.Open(); try { IDbContextTransaction dbContextTransaction = null; try { foreach (MigrationCommand migrationCommand in migrationCommands) { if (dbContextTransaction == null && !migrationCommand.TransactionSuppressed) { dbContextTransaction = connection.BeginTransaction(); } if (dbContextTransaction != null && migrationCommand.TransactionSuppressed) { dbContextTransaction.Commit(); dbContextTransaction.Dispose(); dbContextTransaction = null; } result = ((OracleMigrationCommand)migrationCommand).ExecuteScalar(connection); } dbContextTransaction?.Commit(); } finally { dbContextTransaction?.Dispose(); } } finally { connection.Close(); } } return(result); } catch (Exception ex) { if (Check.IsErrorEnabled(logger?.Logger)) { Trace <DbLoggerCategory.Database> .Write(logger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleMigrationCommandExecutor, OracleTraceFuncName.ExecuteScalar, ex.ToString()); } throw; } finally { if (Check.IsTraceEnabled(logger?.Logger)) { Trace <DbLoggerCategory.Database> .Write(logger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleMigrationCommandExecutor, OracleTraceFuncName.ExecuteScalar); } } }
/// <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?.AreSavepointsSupported == true) { transaction.Save(SavepointName); createdSavepoint = true; } } foreach (var batch in commandBatches) { batch.Execute(connection); rowsAffected += batch.ModificationCommands.Count; } if (beganTransaction) { transaction.Commit(); } } catch { if (createdSavepoint) { transaction.Rollback(SavepointName); } throw; } finally { if (createdSavepoint) { transaction.Release(SavepointName); } else if (beganTransaction) { transaction.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 { 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); }
/// <summary> /// 执行 /// </summary> /// <param name="migrationCommands">迁移命令</param> /// <param name="connection">连接对象</param> /// <param name="logger">日志</param> public void ExecuteNonQuery( IEnumerable <MigrationCommand> migrationCommands, IRelationalConnection connection, IDiagnosticsLogger <DbLoggerCategory.Database> logger = null) { try { if (Check.IsTraceEnabled(logger?.Logger)) { Trace <DbLoggerCategory.Database> .Write(logger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleMigrationCommandExecutor, OracleTraceFuncName.ExecuteNonQuery); } m_oracleLogger = logger; Check.NotNull(migrationCommands, nameof(migrationCommands)); Check.NotNull(connection, nameof(connection)); using (new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled)) { connection.Open(); try { IDbContextTransaction dbContextTransaction = null; try { foreach (MigrationCommand migrationCommand in migrationCommands) { if (dbContextTransaction == null && !migrationCommand.TransactionSuppressed) { dbContextTransaction = connection.BeginTransaction(); } if (dbContextTransaction != null && migrationCommand.TransactionSuppressed) { dbContextTransaction.Commit(); dbContextTransaction.Dispose(); dbContextTransaction = null; } try { migrationCommand.ExecuteNonQuery(connection); } catch (Exception ex) { if (!migrationCommand.CommandText.StartsWith("CREATE UNIQUE INDEX") || (!ex.Message.Contains("ORA-01408") && !ex.Message.Contains("ORA-00955"))) { throw; } } } dbContextTransaction?.Commit(); } finally { dbContextTransaction?.Dispose(); } } finally { connection.Close(); } } } catch (Exception ex) { if (Check.IsErrorEnabled(logger?.Logger)) { Trace <DbLoggerCategory.Database> .Write(m_oracleLogger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleMigrationCommandExecutor, OracleTraceFuncName.ExecuteNonQuery, ex.ToString()); } throw; } finally { if (Check.IsTraceEnabled(logger?.Logger)) { Trace <DbLoggerCategory.Database> .Write(m_oracleLogger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleMigrationCommandExecutor, OracleTraceFuncName.ExecuteNonQuery); } } }
public virtual async Task<int> ExecuteAsync( IEnumerable<ModificationCommandBatch> commandBatches, IRelationalConnection connection, CancellationToken cancellationToken = default(CancellationToken)) { Check.NotNull(commandBatches, nameof(commandBatches)); Check.NotNull(connection, nameof(connection)); var rowsAffected = 0; await connection.OpenAsync(cancellationToken); RelationalTransaction startedTransaction = null; try { if (connection.Transaction == null) { startedTransaction = connection.BeginTransaction(); } foreach (var commandbatch in commandBatches) { rowsAffected += await commandbatch.ExecuteAsync( connection.Transaction, _typeMapper, _context, Logger, cancellationToken); } startedTransaction?.Commit(); } finally { startedTransaction?.Dispose(); connection.Close(); } return rowsAffected; }