public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
await _queryingEnumerable._relationalQueryContext.Semaphore.WaitAsync(cancellationToken);
if (_buffer == null)
{
if (_dataReader == null)
{
await _queryingEnumerable._relationalQueryContext.Connection
.OpenAsync(cancellationToken);
var relationalCommand
= _queryingEnumerable._shaperCommandContext
.GetRelationalCommand(_queryingEnumerable._relationalQueryContext.ParameterValues);
await _queryingEnumerable._relationalQueryContext
.RegisterValueBufferCursorAsync(this, _queryingEnumerable._queryIndex, cancellationToken);
_dataReader
= await relationalCommand.ExecuteReaderAsync(
_queryingEnumerable._relationalQueryContext.Connection,
_queryingEnumerable._relationalQueryContext.ParameterValues,
manageConnection : false,
cancellationToken : cancellationToken);
_dbDataReader = _dataReader.DbDataReader;
_queryingEnumerable._shaperCommandContext.NotifyReaderCreated(_dbDataReader);
_valueBufferFactory = _queryingEnumerable._shaperCommandContext.ValueBufferFactory;
}
var hasNext = await _dbDataReader.ReadAsync(cancellationToken);
_current
= hasNext
? _valueBufferFactory.Create(_dbDataReader)
: default(ValueBuffer);
return(hasNext);
}
if (_buffer.Count > 0)
{
_current = _buffer.Dequeue();
return(true);
}
return(false);
}
finally
{
_queryingEnumerable._relationalQueryContext.Semaphore.Release();
}
}
private async Task <bool> BufferlessMoveNext(bool buffer, CancellationToken cancellationToken)
{
try
{
if (_dataReader == null)
{
await _queryingEnumerable._relationalQueryContext.Connection
.OpenAsync(cancellationToken);
var relationalCommand
= _queryingEnumerable._shaperCommandContext
.GetRelationalCommand(_queryingEnumerable._relationalQueryContext.ParameterValues);
await _queryingEnumerable._relationalQueryContext
.RegisterValueBufferCursorAsync(this, cancellationToken);
_dataReader
= await relationalCommand.ExecuteReaderAsync(
_queryingEnumerable._relationalQueryContext.Connection,
_queryingEnumerable._relationalQueryContext.ParameterValues,
cancellationToken);
_dbDataReader = _dataReader.DbDataReader;
_queryingEnumerable._shaperCommandContext.NotifyReaderCreated(_dbDataReader);
_valueBufferFactory = _queryingEnumerable._shaperCommandContext.ValueBufferFactory;
}
var hasNext = await _dbDataReader.ReadAsync(cancellationToken);
_current
= hasNext
? _valueBufferFactory.Create(_dbDataReader)
: default(ValueBuffer);
if (buffer)
{
await BufferAllAsync(cancellationToken);
}
return(hasNext);
}
catch (Exception)
{
_queryingEnumerable._relationalQueryContext.DeregisterValueBufferCursor(this);
_dataReader = null;
_dbDataReader = null;
throw;
}
}
private async Task <bool> BufferlessMoveNext(DbContext _, bool buffer, CancellationToken cancellationToken)
{
if (_dataReader == null)
{
await _relationalQueryContext.Connection.OpenAsync(cancellationToken);
try
{
var relationalCommand
= _shaperCommandContext
.GetRelationalCommand(_relationalQueryContext.ParameterValues, _relationalQueryContext);
await _relationalQueryContext.Connection
.RegisterBufferableAsync(this, cancellationToken);
_dataReader
= await relationalCommand.ExecuteReaderAsync(
_relationalQueryContext.Connection,
_relationalQueryContext.ParameterValues,
_relationalQueryContext.CommandLogger,
cancellationToken);
}
catch
{
// If failure happens creating the data reader, then it won't be available to
// handle closing the connection, so do it explicitly here to preserve ref counting.
_relationalQueryContext.Connection.Close();
throw;
}
_dbDataReader = _dataReader.DbDataReader;
_shaperCommandContext.NotifyReaderCreated(_dbDataReader);
_valueBufferFactory = _shaperCommandContext.ValueBufferFactory;
}
var hasNext = await _dataReader.ReadAsync(cancellationToken);
Current
= hasNext
? _shaper.Shape(_relationalQueryContext, _valueBufferFactory.Create(_dbDataReader))
: default;
if (buffer)
{
await BufferAllAsync(cancellationToken);
}
return(hasNext);
}
private bool BufferlessMoveNext(bool buffer)
{
try
{
if (_dataReader == null)
{
_queryingEnumerable._relationalQueryContext.Connection.Open();
var relationalCommand
= _queryingEnumerable._shaperCommandContext
.GetRelationalCommand(_queryingEnumerable._relationalQueryContext.ParameterValues);
_queryingEnumerable._relationalQueryContext
.RegisterValueBufferCursor(this, _queryingEnumerable._queryIndex);
_dataReader
= relationalCommand.ExecuteReader(
_queryingEnumerable._relationalQueryContext.Connection,
_queryingEnumerable._relationalQueryContext.ParameterValues);
_dbDataReader = _dataReader.DbDataReader;
_queryingEnumerable._shaperCommandContext.NotifyReaderCreated(_dbDataReader);
_valueBufferFactory = _queryingEnumerable._shaperCommandContext.ValueBufferFactory;
}
var hasNext = _dbDataReader.Read();
_current
= hasNext
? _valueBufferFactory.Create(_dbDataReader)
: default(ValueBuffer);
if (buffer)
{
BufferAll();
}
return(hasNext);
}
catch (Exception)
{
_queryingEnumerable._relationalQueryContext.DeregisterValueBufferCursor(this);
_dataReader = null;
_dbDataReader = null;
throw;
}
}
private bool BufferlessMoveNext(DbContext _, bool buffer)
{
if (_dataReader == null)
{
_relationalQueryContext.Connection.Open();
try
{
var relationalCommand
= _shaperCommandContext
.GetRelationalCommand(_relationalQueryContext.ParameterValues);
_relationalQueryContext.Connection.RegisterBufferable(this);
_dataReader
= relationalCommand.ExecuteReader(
_relationalQueryContext.Connection,
_relationalQueryContext.ParameterValues);
}
catch
{
// If failure happens creating the data reader, then it won't be available to
// handle closing the connection, so do it explicitly here to preserve ref counting.
_relationalQueryContext.Connection.Close();
throw;
}
_dbDataReader = _dataReader.DbDataReader;
_shaperCommandContext.NotifyReaderCreated(_dbDataReader);
_valueBufferFactory = _shaperCommandContext.ValueBufferFactory;
}
var hasNext = _dataReader.Read();
Current
= hasNext
? _shaper.Shape(_relationalQueryContext, _valueBufferFactory.Create(_dbDataReader))
: default;
if (buffer)
{
BufferAll();
}
return(hasNext);
}
public bool MoveNext()
{
if (_buffer == null)
{
if (_dataReader == null)
{
_queryingEnumerable._relationalQueryContext.Connection.Open();
var relationalCommand
= _queryingEnumerable._shaperCommandContext
.GetRelationalCommand(_queryingEnumerable._relationalQueryContext.ParameterValues);
_queryingEnumerable._relationalQueryContext
.RegisterValueBufferCursor(this, _queryingEnumerable._queryIndex);
_dataReader
= relationalCommand.ExecuteReader(
_queryingEnumerable._relationalQueryContext.Connection,
_queryingEnumerable._relationalQueryContext.ParameterValues,
manageConnection: false);
_dbDataReader = _dataReader.DbDataReader;
_queryingEnumerable._shaperCommandContext.NotifyReaderCreated(_dbDataReader);
_valueBufferFactory = _queryingEnumerable._shaperCommandContext.ValueBufferFactory;
}
var hasNext = _dbDataReader.Read();
_current
= hasNext
? _valueBufferFactory.Create(_dbDataReader)
: default(ValueBuffer);
return(hasNext);
}
if (_buffer.Count > 0)
{
_current = _buffer.Dequeue();
return(true);
}
return(false);
}
/// <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);
}
}