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