protected virtual async Task <DbValue[]> ReadRow(AsyncWrappingCommonArgs async)
{
var row = new DbValue[_fields.Count];
try
{
for (var i = 0; i < _fields.Count; i++)
{
var value = await ReadRawValue(_database.Xdr, _fields[i], async).ConfigureAwait(false);
var sqlInd = await _database.Xdr.ReadInt32(async).ConfigureAwait(false);
if (sqlInd == -1)
{
row[i] = new DbValue(this, _fields[i], null);
}
else if (sqlInd == 0)
{
row[i] = new DbValue(this, _fields[i], value);
}
else
{
throw IscException.ForStrParam($"Invalid {nameof(sqlInd)} value: {sqlInd}.");
}
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
return(row);
}
protected override async Task <DbValue[]> ReadRow(AsyncWrappingCommonArgs async)
{
var row = new DbValue[_fields.Count];
try
{
if (_fields.Count > 0)
{
var nullBytes = await _database.Xdr.ReadOpaque((int)Math.Ceiling(_fields.Count / 8d), async).ConfigureAwait(false);
var nullBits = new BitArray(nullBytes);
for (var i = 0; i < _fields.Count; i++)
{
if (nullBits.Get(i))
{
row[i] = new DbValue(this, _fields[i], null);
}
else
{
var value = await ReadRawValue(_database.Xdr, _fields[i], async).ConfigureAwait(false);
row[i] = new DbValue(this, _fields[i], value);
}
}
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
return(row);
}
public override async Task Prepare(byte[] buffer, AsyncWrappingCommonArgs async)
{
EnsureActiveTransactionState();
try
{
State = TransactionState.NoTransaction;
await _database.Xdr.Write(IscCodes.op_prepare2, async).ConfigureAwait(false);
await _database.Xdr.Write(_handle, async).ConfigureAwait(false);
await _database.Xdr.WriteBuffer(buffer, buffer.Length, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
await _database.ReadResponse(async).ConfigureAwait(false);
State = TransactionState.Prepared;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async ValueTask PrepareAsync(byte[] buffer, CancellationToken cancellationToken = default)
{
EnsureActiveTransactionState();
try
{
State = TransactionState.NoTransaction;
await _database.Xdr.WriteAsync(IscCodes.op_prepare2, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(_handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(buffer, buffer.Length, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
State = TransactionState.Prepared;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async Task PutSlice(Array sourceArray, int sliceLength, AsyncWrappingCommonArgs async)
{
try
{
var sdl = GenerateSDL(Descriptor);
var slice = await EncodeSliceArray(sourceArray, async).ConfigureAwait(false);
await _database.Xdr.Write(IscCodes.op_put_slice, async).ConfigureAwait(false);
await _database.Xdr.Write(_transaction.Handle, async).ConfigureAwait(false);
await _database.Xdr.Write(ArrayHandle, async).ConfigureAwait(false);
await _database.Xdr.Write(sliceLength, async).ConfigureAwait(false);
await _database.Xdr.WriteBuffer(sdl, async).ConfigureAwait(false);
await _database.Xdr.Write(string.Empty, async).ConfigureAwait(false);
await _database.Xdr.Write(sliceLength, async).ConfigureAwait(false);
await _database.Xdr.WriteBytes(slice, slice.Length, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
_handle = response.BlobId;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
private async ValueTask CreateOrOpenAsync(int op, BlobParameterBuffer bpb, CancellationToken cancellationToken = default)
{
try
{
await _database.Xdr.WriteAsync(op, cancellationToken).ConfigureAwait(false);
if (bpb != null)
{
await _database.Xdr.WriteTypedAsync(IscCodes.isc_bpb_version1, bpb.ToArray(), cancellationToken).ConfigureAwait(false);
}
await _database.Xdr.WriteAsync(_transaction.Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(_blobId, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
_blobId = response.BlobId;
_blobHandle = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async ValueTask BeginTransactionAsync(TransactionParameterBuffer tpb, CancellationToken cancellationToken = default)
{
if (State != TransactionState.NoTransaction)
{
throw new InvalidOperationException();
}
try
{
await _database.Xdr.WriteAsync(IscCodes.op_transaction, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(_database.Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(tpb.ToArray(), cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
_database.TransactionCount++;
_handle = response.ObjectHandle;
State = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async ValueTask <byte[]> GetSliceAsync(int sliceLength, CancellationToken cancellationToken = default)
{
try
{
var sdl = GenerateSDL(Descriptor);
await _database.Xdr.WriteAsync(IscCodes.op_get_slice, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(_transaction.Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(_handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(sliceLength, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(sdl, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(string.Empty, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(0, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
return(await ReceiveSliceResponseAsync(Descriptor, cancellationToken).ConfigureAwait(false));
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override void PutSlice(Array sourceArray, int sliceLength)
{
try
{
var sdl = GenerateSDL(Descriptor);
var slice = EncodeSliceArray(sourceArray);
_database.Xdr.Write(IscCodes.op_put_slice);
_database.Xdr.Write(_transaction.Handle);
_database.Xdr.Write(ArrayHandle);
_database.Xdr.Write(sliceLength);
_database.Xdr.WriteBuffer(sdl);
_database.Xdr.Write(string.Empty);
_database.Xdr.Write(sliceLength);
_database.Xdr.WriteBytes(slice, slice.Length);
_database.Xdr.Flush();
var response = (GenericResponse)_database.ReadResponse();
_handle = response.BlobId;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected override DbValue[] ReadRow()
{
var row = new DbValue[_fields.Count];
try
{
if (_fields.Count > 0)
{
var nullBytes = _database.Xdr.ReadOpaque((int)Math.Ceiling(_fields.Count / 8d));
var nullBits = new BitArray(nullBytes);
for (var i = 0; i < _fields.Count; i++)
{
if (nullBits.Get(i))
{
row[i] = new DbValue(this, _fields[i], null);
}
else
{
var value = ReadRawValue(_database.Xdr, _fields[i]);
row[i] = new DbValue(this, _fields[i], value);
}
}
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
return(row);
}
public override async ValueTask AttachAsync(DatabaseParameterBufferBase dpb, string database, byte[] cryptKey, CancellationToken cancellationToken = default)
{
try
{
await SendAttachToBufferAsync(dpb, database, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = await ReadResponseAsync(cancellationToken).ConfigureAwait(false);
if (response is ContAuthResponse)
{
while (response is ContAuthResponse contAuthResponse)
{
AuthBlock.Start(contAuthResponse.ServerData, contAuthResponse.AcceptPluginName, contAuthResponse.IsAuthenticated, contAuthResponse.ServerKeys);
await AuthBlock.SendContAuthToBufferAsync(Xdr, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
response = await AuthBlock.ProcessContAuthResponseAsync(Xdr, cancellationToken).ConfigureAwait(false);
response = await ProcessCryptCallbackResponseIfNeededAsync(response, cryptKey, cancellationToken).ConfigureAwait(false);
}
var genericResponse = (GenericResponse)response;
await ProcessAttachResponseAsync(genericResponse, cancellationToken).ConfigureAwait(false);
if (genericResponse.Data.Any())
{
await AuthBlock.SendWireCryptToBufferAsync(Xdr, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
await AuthBlock.ProcessWireCryptResponseAsync(Xdr, _connection, cancellationToken).ConfigureAwait(false);
}
}
else
{
response = await ProcessCryptCallbackResponseIfNeededAsync(response, cryptKey, cancellationToken).ConfigureAwait(false);
await ProcessAttachResponseAsync((GenericResponse)response, cancellationToken).ConfigureAwait(false);
AuthBlock.Complete();
}
AuthBlock.WireCryptValidate(IscCodes.PROTOCOL_VERSION13);
}
catch (IscException)
{
await SafelyDetachAsync(cancellationToken).ConfigureAwait(false);
throw;
}
catch (IOException ex)
{
await SafelyDetachAsync(cancellationToken).ConfigureAwait(false);
throw IscException.ForIOException(ex);
}
await AfterAttachActionsAsync(cancellationToken).ConfigureAwait(false);
}
private async Task CreateOrOpen(int op, BlobParameterBuffer bpb, AsyncWrappingCommonArgs async)
{
try
{
await _database.Xdr.Write(op, async).ConfigureAwait(false);
if (bpb != null)
{
await _database.Xdr.WriteTyped(IscCodes.isc_bpb_version1, bpb.ToArray(), async).ConfigureAwait(false);
}
await _database.Xdr.Write(_transaction.Handle, async).ConfigureAwait(false);
await _database.Xdr.Write(_blobId, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
_blobId = response.BlobId;
_blobHandle = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected async Task DoFreePacket(int option, AsyncWrappingCommonArgs async)
{
try
{
await _database.Xdr.Write(IscCodes.op_free_statement, async).ConfigureAwait(false);
await _database.Xdr.Write(_handle, async).ConfigureAwait(false);
await _database.Xdr.Write(option, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
if (option == IscCodes.DSQL_drop)
{
_parameters = null;
_fields = null;
}
Clear();
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForIOException(ex);
}
}
public override async Task Prepare(string commandText, AsyncWrappingCommonArgs async)
{
ClearAll();
try
{
if (State == StatementState.Deallocated)
{
await SendAllocateToBuffer(async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
await ProcessAllocateResponse((GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false), async).ConfigureAwait(false);
}
await SendPrepareToBuffer(commandText, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
await ProcessPrepareResponse((GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false), async).ConfigureAwait(false);
await SendInfoSqlToBuffer(StatementTypeInfoItems, IscCodes.STATEMENT_TYPE_BUFFER_SIZE, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
StatementType = ProcessStatementTypeInfoBuffer(await ProcessInfoSqlResponse((GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false), async).ConfigureAwait(false));
State = StatementState.Prepared;
}
catch (IOException ex)
{
State = State == StatementState.Allocated ? StatementState.Error : State;
throw IscException.ForIOException(ex);
}
}
private void DatabaseInfo(byte[] items, byte[] buffer, int bufferLength)
{
try
{
Xdr.Write(IscCodes.op_info_database);
Xdr.Write(_handle);
Xdr.Write(Incarnation);
Xdr.WriteBuffer(items, items.Length);
Xdr.Write(bufferLength);
Xdr.Flush();
var response = (GenericResponse)ReadResponse();
var responseLength = bufferLength;
if (response.Data.Length < bufferLength)
{
responseLength = response.Data.Length;
}
Buffer.BlockCopy(response.Data, 0, buffer, 0, responseLength);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async ValueTask PutSliceAsync(Array sourceArray, int sliceLength, CancellationToken cancellationToken = default)
{
try
{
var sdl = GenerateSDL(Descriptor);
var slice = await EncodeSliceArrayAsync(sourceArray, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(IscCodes.op_put_slice, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(_transaction.Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(ArrayHandle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(sliceLength, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(sdl, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(string.Empty, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(sliceLength, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBytesAsync(slice, slice.Length, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
_handle = response.BlobId;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
private async ValueTask DatabaseInfoAsync(byte[] items, byte[] buffer, int bufferLength, CancellationToken cancellationToken = default)
{
try
{
await Xdr.WriteAsync(IscCodes.op_info_database, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(_handle, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(Incarnation, cancellationToken).ConfigureAwait(false);
await Xdr.WriteBufferAsync(items, items.Length, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(bufferLength, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse) await ReadResponseAsync(cancellationToken).ConfigureAwait(false);
var responseLength = bufferLength;
if (response.Data.Length < bufferLength)
{
responseLength = response.Data.Length;
}
Buffer.BlockCopy(response.Data, 0, buffer, 0, responseLength);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override void Detach()
{
try
{
_database.Xdr.Write(IscCodes.op_service_detach);
_database.Xdr.Write(Handle);
_database.Xdr.Write(IscCodes.op_disconnect);
_database.Xdr.Flush();
Handle = 0;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
finally
{
try
{
_connection.Disconnect();
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
finally
{
_database = null;
_connection = null;
}
}
}
private async Task DatabaseInfo(byte[] items, byte[] buffer, int bufferLength, AsyncWrappingCommonArgs async)
{
try
{
await Xdr.Write(IscCodes.op_info_database, async).ConfigureAwait(false);
await Xdr.Write(_handle, async).ConfigureAwait(false);
await Xdr.Write(Incarnation, async).ConfigureAwait(false);
await Xdr.WriteBuffer(items, items.Length, async).ConfigureAwait(false);
await Xdr.Write(bufferLength, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
var response = (GenericResponse) await ReadResponse(async).ConfigureAwait(false);
var responseLength = bufferLength;
if (response.Data.Length < bufferLength)
{
responseLength = response.Data.Length;
}
Buffer.BlockCopy(response.Data, 0, buffer, 0, responseLength);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async ValueTask DetachAsync(CancellationToken cancellationToken = default)
{
try
{
await _database.Xdr.WriteAsync(IscCodes.op_service_detach, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(IscCodes.op_disconnect, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
Handle = 0;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
finally
{
try
{
await _connection.DisconnectAsync(cancellationToken).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
finally
{
_database = null;
_connection = null;
}
}
}
public override async ValueTask RollbackAsync(CancellationToken cancellationToken = default)
{
EnsureActiveTransactionState();
try
{
await _database.Xdr.WriteAsync(IscCodes.op_rollback, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(_handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
_database.TransactionCount--;
OnUpdate(EventArgs.Empty);
State = TransactionState.NoTransaction;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async ValueTask StartAsync(ServiceParameterBufferBase spb, CancellationToken cancellationToken = default)
{
try
{
await _database.Xdr.WriteAsync(IscCodes.op_service_start, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(0, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(spb.ToArray(), spb.Length, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
try
{
await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
}
catch (IscException)
{
throw;
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override void BeginTransaction(TransactionParameterBuffer tpb)
{
if (State != TransactionState.NoTransaction)
{
throw new InvalidOperationException();
}
try
{
_database.Xdr.Write(IscCodes.op_transaction);
_database.Xdr.Write(_database.Handle);
_database.Xdr.WriteBuffer(tpb.ToArray());
_database.Xdr.Flush();
var response = (GenericResponse)_database.ReadResponse();
_database.TransactionCount++;
_handle = response.ObjectHandle;
State = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override void Query(ServiceParameterBufferBase spb, int requestLength, byte[] requestBuffer, int bufferLength, byte[] buffer)
{
try
{
_database.Xdr.Write(IscCodes.op_service_info);
_database.Xdr.Write(Handle);
_database.Xdr.Write(GdsDatabase.Incarnation);
_database.Xdr.WriteBuffer(spb.ToArray(), spb.Length);
_database.Xdr.WriteBuffer(requestBuffer, requestLength);
_database.Xdr.Write(bufferLength);
_database.Xdr.Flush();
var response = (GenericResponse)_database.ReadResponse();
var responseLength = bufferLength;
if (response.Data.Length < bufferLength)
{
responseLength = response.Data.Length;
}
Buffer.BlockCopy(response.Data, 0, buffer, 0, responseLength);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async Task <byte[]> GetSlice(int sliceLength, AsyncWrappingCommonArgs async)
{
try
{
var sdl = GenerateSDL(Descriptor);
await _database.Xdr.Write(IscCodes.op_get_slice, async).ConfigureAwait(false);
await _database.Xdr.Write(_transaction.Handle, async).ConfigureAwait(false);
await _database.Xdr.Write(_handle, async).ConfigureAwait(false);
await _database.Xdr.Write(sliceLength, async).ConfigureAwait(false);
await _database.Xdr.WriteBuffer(sdl, async).ConfigureAwait(false);
await _database.Xdr.Write(string.Empty, async).ConfigureAwait(false);
await _database.Xdr.Write(0, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
return(await ReceiveSliceResponse(Descriptor, async).ConfigureAwait(false));
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async ValueTask QueryAsync(ServiceParameterBufferBase spb, int requestLength, byte[] requestBuffer, int bufferLength, byte[] buffer, CancellationToken cancellationToken = default)
{
try
{
await _database.Xdr.WriteAsync(IscCodes.op_service_info, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(Handle, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(GdsDatabase.Incarnation, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(spb.ToArray(), spb.Length, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteBufferAsync(requestBuffer, requestLength, cancellationToken).ConfigureAwait(false);
await _database.Xdr.WriteAsync(bufferLength, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
var responseLength = bufferLength;
if (response.Data.Length < bufferLength)
{
responseLength = response.Data.Length;
}
Buffer.BlockCopy(response.Data, 0, buffer, 0, responseLength);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async Task Rollback(AsyncWrappingCommonArgs async)
{
EnsureActiveTransactionState();
try
{
await _database.Xdr.Write(IscCodes.op_rollback, async).ConfigureAwait(false);
await _database.Xdr.Write(_handle, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
await _database.ReadResponse(async).ConfigureAwait(false);
_database.TransactionCount--;
OnUpdate(EventArgs.Empty);
State = TransactionState.NoTransaction;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override void QueueEvents(RemoteEvent remoteEvent)
{
try
{
if (_eventManager == null)
{
var(auxHandle, ipAddress, portNumber, timeout) = ConnectionRequest();
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber, timeout);
_eventManager.Open();
var dummy = _eventManager.StartWaitingForEvents(remoteEvent);
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
Xdr.Write(IscCodes.op_que_events);
Xdr.Write(_handle);
Xdr.WriteBuffer(epbData);
Xdr.Write(AddressOfAstRoutine);
Xdr.Write(ArgumentToAstRoutine);
Xdr.Write(remoteEvent.LocalId);
Xdr.Flush();
var response = (GenericResponse)ReadResponse();
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async Task BeginTransaction(TransactionParameterBuffer tpb, AsyncWrappingCommonArgs async)
{
if (State != TransactionState.NoTransaction)
{
throw new InvalidOperationException();
}
try
{
await _database.Xdr.Write(IscCodes.op_transaction, async).ConfigureAwait(false);
await _database.Xdr.Write(_database.Handle, async).ConfigureAwait(false);
await _database.Xdr.WriteBuffer(tpb.ToArray(), async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
var response = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
_database.TransactionCount++;
_handle = response.ObjectHandle;
State = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected virtual async Task <byte[]> WriteParameters(AsyncWrappingCommonArgs async)
{
if (_parameters == null)
{
return(null);
}
using (var ms = new MemoryStream())
{
var xdr = new XdrReaderWriter(new DataProviderStreamWrapper(ms), _database.Charset);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
try
{
await WriteRawParameter(xdr, field, async).ConfigureAwait(false);
await xdr.Write(field.NullFlag, async).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
await xdr.Flush(async).ConfigureAwait(false);
return(ms.ToArray());
}
}
