/// <summary>
/// Executes the command generated by <see cref="CreateStoreCommand" /> against a
/// database using the given connection.
/// </summary>
/// <param name="connection"> The connection to the database to update. </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. </returns>
/// <exception cref="OperationCanceledException"> If the <see cref="CancellationToken"/> is canceled. </exception>
public override async Task ExecuteAsync(
IRelationalConnection connection,
CancellationToken cancellationToken = default)
{
Check.NotNull(connection, nameof(connection));
var storeCommand = CreateStoreCommand();
try
{
await using var dataReader = await storeCommand.RelationalCommand.ExecuteReaderAsync(
new RelationalCommandParameterObject (
connection,
storeCommand.ParameterValues,
null,
Dependencies.CurrentContext.Context,
Dependencies.Logger),
cancellationToken).ConfigureAwait(false);
await ConsumeAsync(dataReader, cancellationToken).ConfigureAwait(false);
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(
RelationalStrings.UpdateStoreException,
ex,
ModificationCommands.SelectMany(c => c.Entries).ToList());
}
}
protected virtual IRelationalCommand CreateStoreCommand()
{
var commandBuilder = _commandBuilderFactory
.Create()
.Append(GetCommandText());
foreach (var columnModification in ModificationCommands.SelectMany(t => t.ColumnModifications))
{
if (columnModification.ParameterName != null)
{
commandBuilder.AddParameter(
SqlGenerationHelper.GenerateParameterName(columnModification.ParameterName),
columnModification.Value,
columnModification.Property);
}
if (columnModification.OriginalParameterName != null)
{
commandBuilder.AddParameter(
SqlGenerationHelper.GenerateParameterName(columnModification.OriginalParameterName),
columnModification.OriginalValue,
columnModification.Property);
}
}
return(commandBuilder.Build());
}
/// <summary>
/// Executes the command generated by <see cref="CreateStoreCommand" /> against a
/// database using the given connection.
/// </summary>
/// <param name="connection"> The connection to the database to update. </param>
public override void Execute(IRelationalConnection connection)
{
Check.NotNull(connection, nameof(connection));
var storeCommand = CreateStoreCommand();
try
{
using var dataReader = storeCommand.RelationalCommand.ExecuteReader(
new RelationalCommandParameterObject(
connection,
storeCommand.ParameterValues,
null,
Dependencies.CurrentContext.Context,
Dependencies.Logger));
Consume(dataReader);
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(
RelationalStrings.UpdateStoreException,
ex,
ModificationCommands.SelectMany(c => c.Entries).ToList());
}
}
protected override RawSqlCommand CreateStoreCommand()
{
var commandBuilder = _commandBuilderFactory
.Create()
.Append(GetCommandText());
var parameterValues = new Dictionary <string, object>(GetParameterCount());
foreach (var columnModification in ModificationCommands.SelectMany(t => t.ColumnModifications))
{
if (columnModification.UseCurrentValueParameter)
{
commandBuilder.AddParameter(
columnModification.ParameterName,
SqlGenerationHelper.GenerateParameterName(columnModification.ParameterName),
columnModification.Property);
parameterValues.Add(
columnModification.ParameterName,
columnModification.Value);
}
if (columnModification.UseOriginalValueParameter)
{
commandBuilder.AddParameter(
columnModification.OriginalParameterName,
SqlGenerationHelper.GenerateParameterName(columnModification.OriginalParameterName),
columnModification.Property);
parameterValues.Add(
columnModification.OriginalParameterName,
columnModification.OriginalValue);
}
}
for (var i = 1; i < _cursorPosition; i++)
{
var nameParameter = $"cur{i}";
commandBuilder.AddRawParameter(
nameParameter,
new OracleParameter(
nameParameter,
OracleDbType.RefCursor,
DBNull.Value,
ParameterDirection.Output));
}
return(new RawSqlCommand(
commandBuilder.Build(),
parameterValues));
}
/// <summary>
/// 创建存储过程命令
/// </summary>
/// <returns></returns>
protected override RawSqlCommand CreateStoreCommand()
{
try
{
if (Check.IsTraceEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.CreateStoreCommand);
}
var commandText = GetCommandText();
var ommandBuilder = _commandBuilderFactory.Create().Append(commandText);
var parameterValues = new Dictionary <string, object>(GetParameterCount());
foreach (ColumnModification item in ModificationCommands.SelectMany((ModificationCommand t) => t.ColumnModifications))
{
if (item.UseCurrentValueParameter)
{
ommandBuilder.AddParameter(item.ParameterName, SqlGenerationHelper.GenerateParameterName(item.ParameterName), item.Property);
parameterValues.Add(item.ParameterName, item.Value);
}
if (item.UseOriginalValueParameter)
{
ommandBuilder.AddParameter(item.OriginalParameterName, SqlGenerationHelper.GenerateParameterName(item.OriginalParameterName), item.Property);
parameterValues.Add(item.OriginalParameterName, item.OriginalValue);
}
}
for (int i = 1; i < _cursorPosition; i++)
{
var parameterName = $"cur{i}";
ommandBuilder.AddRawParameter(parameterName, (DbParameter) new OracleParameter(parameterName, OracleDbType.RefCursor, (object)DBNull.Value, ParameterDirection.Output));
}
return(new RawSqlCommand(ommandBuilder.Build(), parameterValues));
}
catch (Exception ex)
{
if (Check.IsErrorEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.CreateStoreCommand, ex.ToString());
}
throw;
}
finally
{
if (Check.IsTraceEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.CreateStoreCommand);
}
}
}
protected virtual DbCommand CreateStoreCommand(
[NotNull] string commandText,
[NotNull] DbTransaction transaction,
[NotNull] RelationalTypeMapper typeMapper)
{
var command = transaction.Connection.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = commandText;
command.Transaction = transaction;
foreach (var columnModification in ModificationCommands.SelectMany(t => t.ColumnModifications))
{
PopulateParameters(command, columnModification, typeMapper);
}
return(command);
}
protected virtual RawSqlCommand CreateStoreCommand()
{
var commandBuilder = _commandBuilderFactory
.Create()
.Append(GetCommandText());
var parameterValues = new Dictionary <string, object>(GetParameterCount());
foreach (var columnModification in ModificationCommands.SelectMany(t => t.ColumnModifications))
{
if (columnModification.ParameterName != null)
{
commandBuilder.AddParameter(
columnModification.ParameterName,
SqlGenerationHelper.GenerateParameterName(columnModification.ParameterName),
columnModification.Property);
parameterValues.Add(
columnModification.ParameterName,
columnModification.Value);
}
if (columnModification.OriginalParameterName != null)
{
commandBuilder.AddParameter(
columnModification.OriginalParameterName,
SqlGenerationHelper.GenerateParameterName(columnModification.OriginalParameterName),
columnModification.Property);
parameterValues.Add(
columnModification.OriginalParameterName,
columnModification.OriginalValue);
}
}
return(new RawSqlCommand(
commandBuilder.Build(),
parameterValues));
}
/// <summary> /// Gets the total number of parameters needed for the batch. /// </summary> /// <returns> The total parameter count. </returns> protected virtual int GetParameterCount() => ModificationCommands.Sum(c => c.ColumnModifications.Count);
protected override async Task ConsumeAsync(
RelationalDataReader relationalReader, CancellationToken cancellationToken = default)
{
var commandPosition = 0;
int rowsAffected;
try
{
do
{
while (commandPosition < CommandResultSet.Count &&
CommandResultSet[commandPosition] == ResultSetMapping.NoResultSet)
{
commandPosition++;
}
if (commandPosition < CommandResultSet.Count)
{
if (ModificationCommands[commandPosition].RequiresResultPropagation)
{
rowsAffected = 0;
do
{
var tableModification = ModificationCommands[commandPosition];
if (!await relationalReader.ReadAsync(cancellationToken))
{
throw new DbUpdateConcurrencyException(
RelationalStrings.UpdateConcurrencyException(
ModificationCommands.Count(m => m.RequiresResultPropagation), rowsAffected),
ModificationCommands[commandPosition].Entries);
}
var valueBufferFactory = CreateValueBufferFactory(tableModification.ColumnModifications);
tableModification.PropagateResults(valueBufferFactory.Create(relationalReader.DbDataReader));
rowsAffected++;
}while (++commandPosition < CommandResultSet.Count &&
CommandResultSet[commandPosition - 1] == ResultSetMapping.NotLastInResultSet);
}
else
{
var expectedRowsAffected = 1;
while (++commandPosition < CommandResultSet.Count &&
CommandResultSet[commandPosition - 1] == ResultSetMapping.NotLastInResultSet)
{
expectedRowsAffected++;
}
if (relationalReader.Read())
{
rowsAffected = relationalReader.DbDataReader.GetInt32(0);
if (rowsAffected != expectedRowsAffected)
{
throw new DbUpdateConcurrencyException(
RelationalStrings.UpdateConcurrencyException(expectedRowsAffected, rowsAffected),
ModificationCommands[commandPosition - 1].Entries);
}
}
else
{
throw new DbUpdateConcurrencyException(
RelationalStrings.UpdateConcurrencyException(1, 0),
ModificationCommands[commandPosition - 1].Entries);
}
}
}
}while (commandPosition < CommandResultSet.Count &&
await relationalReader.DbDataReader.NextResultAsync(cancellationToken));
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(
RelationalStrings.UpdateStoreException,
ex, ModificationCommands[commandPosition].Entries);
}
}
/// <summary>
/// 异步恢复
/// </summary>
/// <param name="relationalReader">关系DataReader</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns></returns>
protected override async Task ConsumeAsync(RelationalDataReader relationalReader, CancellationToken cancellationToken = default(CancellationToken))
{
int commandPosition = 0;
try
{
if (Check.IsTraceEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.ConsumeAsync);
}
while (true)
{
if (commandPosition < CommandResultSet.Count && CommandResultSet[commandPosition] == ResultSetMapping.NoResultSet)
{
commandPosition++;
}
else
{
if (commandPosition < CommandResultSet.Count)
{
if (ModificationCommands[commandPosition].RequiresResultPropagation)
{
int rowsAffected = 0;
int num = 0;
do
{
ModificationCommand tableModification = ModificationCommands[commandPosition];
if (!(await relationalReader.ReadAsync(cancellationToken)))
{
throw new DbUpdateConcurrencyException(RelationalStrings.UpdateConcurrencyException(ModificationCommands.Count((ModificationCommand m) => m.RequiresResultPropagation), rowsAffected), ModificationCommands[commandPosition].Entries);
}
IRelationalValueBufferFactory relationalValueBufferFactory = CreateValueBufferFactory(tableModification.ColumnModifications);
tableModification.PropagateResults(relationalValueBufferFactory.Create(relationalReader.DbDataReader));
rowsAffected++;
num = commandPosition + 1;
commandPosition = num;
}while (num < CommandResultSet.Count && CommandResultSet[commandPosition - 1] == ResultSetMapping.NotLastInResultSet);
}
else
{
int expectedRowsAffected = 1;
while (true)
{
int num = commandPosition + 1;
commandPosition = num;
if (num >= CommandResultSet.Count || CommandResultSet[commandPosition - 1] != ResultSetMapping.NotLastInResultSet)
{
break;
}
expectedRowsAffected++;
}
if (!relationalReader.Read())
{
break;
}
int rowsAffected = relationalReader.DbDataReader.GetInt32(0);
if (rowsAffected != expectedRowsAffected)
{
throw new DbUpdateConcurrencyException(RelationalStrings.UpdateConcurrencyException(expectedRowsAffected, rowsAffected), ModificationCommands[commandPosition - 1].Entries);
}
}
}
bool flag = commandPosition < CommandResultSet.Count;
if (flag)
{
flag = await relationalReader.DbDataReader.NextResultAsync(cancellationToken);
}
if (!flag)
{
return;
}
}
}
throw new DbUpdateConcurrencyException(RelationalStrings.UpdateConcurrencyException(1, 0), ModificationCommands[commandPosition - 1].Entries);
}
catch (DbUpdateException dbEx)
{
if (Check.IsErrorEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.ConsumeAsync, dbEx.ToString());
}
throw;
}
catch (Exception ex)
{
if (Check.IsErrorEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.ConsumeAsync, ex.ToString());
}
throw new DbUpdateException(RelationalStrings.UpdateStoreException, ex, ModificationCommands[commandPosition].Entries);
}
}
/// <summary>
/// 恢复
/// </summary>
/// <param name="relationalReader">关系DataReader</param>
protected override void Consume(RelationalDataReader relationalReader)
{
int commandPosition = 0;
int rowsAffected = 0;
try
{
if (Check.IsTraceEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.Consume);
}
while (true)
{
if (commandPosition < CommandResultSet.Count && CommandResultSet[commandPosition] == ResultSetMapping.NoResultSet)
{
commandPosition++;
}
else
{
if (commandPosition < CommandResultSet.Count)
{
if (ModificationCommands[commandPosition].RequiresResultPropagation)
{
rowsAffected = 0;
do
{
ModificationCommand modificationCommand = ModificationCommands[commandPosition];
if (!relationalReader.Read())
{
throw new DbUpdateConcurrencyException(RelationalStrings.UpdateConcurrencyException(ModificationCommands.Count((ModificationCommand m) => m.RequiresResultPropagation), rowsAffected), ModificationCommands[commandPosition].Entries);
}
IRelationalValueBufferFactory relationalValueBufferFactory = CreateValueBufferFactory(modificationCommand.ColumnModifications);
modificationCommand.PropagateResults(relationalValueBufferFactory.Create(relationalReader.DbDataReader));
rowsAffected++;
foreach (ColumnModification columnModification in modificationCommand.ColumnModifications)
{
if (Check.IsTraceEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Trace, OracleTraceTag.SQL, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.Consume, $"Column Name: {columnModification.ColumnName}");
}
}
}while (++commandPosition < CommandResultSet.Count && CommandResultSet[commandPosition - 1] == ResultSetMapping.NotLastInResultSet);
}
else
{
int expectedRowsAffected = 1;
while (++commandPosition < CommandResultSet.Count && CommandResultSet[commandPosition - 1] == ResultSetMapping.NotLastInResultSet)
{
expectedRowsAffected++;
}
if (!relationalReader.Read())
{
break;
}
rowsAffected = relationalReader.DbDataReader.GetInt32(0);
if (rowsAffected != expectedRowsAffected)
{
throw new DbUpdateConcurrencyException(RelationalStrings.UpdateConcurrencyException(expectedRowsAffected, rowsAffected), ModificationCommands[commandPosition - 1].Entries);
}
}
}
if (commandPosition >= CommandResultSet.Count || !relationalReader.DbDataReader.NextResult())
{
return;
}
}
}
throw new DbUpdateConcurrencyException(RelationalStrings.UpdateConcurrencyException(1, 0), ModificationCommands[commandPosition - 1].Entries);
}
catch (DbUpdateException dbEx)
{
if (Check.IsErrorEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.Consume, dbEx.ToString());
}
throw;
}
catch (Exception ex)
{
if (Check.IsErrorEnabled(m_oracleLogger?.Logger))
{
Trace <DbLoggerCategory.Update> .Write(m_oracleLogger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleModificationCommandBatch, OracleTraceFuncName.Consume, ex.ToString());
}
throw new DbUpdateException(RelationalStrings.UpdateStoreException, ex, ModificationCommands[commandPosition - 1].Entries);
}
}
protected override async Task ConsumeAsync(RelationalDataReader relationalReader, CancellationToken cancellationToken = default(CancellationToken))
{
if (relationalReader == null)
{
throw new ArgumentNullException(nameof(relationalReader));
}
var dataReader = relationalReader.DbDataReader;
var commandIndex = 0;
try
{
while (true)
{
while (commandIndex < CommandResultSet.Count && CommandResultSet[commandIndex] == ResultSetMapping.NoResultSet)
{
commandIndex++;
}
var propragation = commandIndex;
while (propragation < ModificationCommands.Count && !ModificationCommands[propragation].RequiresResultPropagation)
{
propragation++;
}
while (commandIndex < propragation)
{
commandIndex++;
if (!(await relationalReader.ReadAsync()))
{
throw new DbUpdateConcurrencyException(
RelationalStrings.UpdateConcurrencyException(
ModificationCommands.Count(m => m.RequiresResultPropagation), 0),
ModificationCommands[commandIndex].Entries);
}
}
//check if you've gone through all notifications
if (propragation == ModificationCommands.Count)
{
break;
}
var modifications = ModificationCommands[commandIndex];
if (!(await relationalReader.ReadAsync()))
{
throw new DbUpdateConcurrencyException(
RelationalStrings.UpdateConcurrencyException(
ModificationCommands.Count(m => m.RequiresResultPropagation), 0),
ModificationCommands[commandIndex].Entries);
}
var bufferFactory = CreateValueBufferFactory(modifications.ColumnModifications);
modifications.PropagateResults(bufferFactory.Create(dataReader));
await dataReader.NextResultAsync();
commandIndex++;
}
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(
RelationalStrings.UpdateStoreException,
ex, ModificationCommands[commandIndex].Entries);
}
}
protected override bool CanAddCommand(ModificationCommand modificationCommand, string newSql)
{
return(!ModificationCommands.Any());
}
