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 = _database.ReadResponse <GenericResponse>(); _handle = response.BlobId; } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_network_error, 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); } }
protected override byte[] GetSegment() { var requested = SegmentSize; try { _database.Xdr.Write(IscCodes.op_get_segment); _database.Xdr.Write(_blobHandle); _database.Xdr.Write(requested < short.MaxValue - 12 ? requested : short.MaxValue - 12); _database.Xdr.Write(DataSegment); _database.Xdr.Flush(); var response = _database.ReadResponse <GenericResponse>(); RblRemoveValue(IscCodes.RBL_segment); if (response.ObjectHandle == 1) { RblAddValue(IscCodes.RBL_segment); } else if (response.ObjectHandle == 2) { RblAddValue(IscCodes.RBL_eof_pending); } var buffer = response.Data; if (buffer.Length == 0) { // previous segment was last, this has no data return(buffer); } var len = 0; var srcpos = 0; var destpos = 0; while (srcpos < buffer.Length) { len = (int)IscHelper.VaxInteger(buffer, srcpos, 2); srcpos += 2; Buffer.BlockCopy(buffer, srcpos, buffer, destpos, len); srcpos += len; destpos += len; } var result = new byte[destpos]; Buffer.BlockCopy(buffer, 0, result, 0, destpos); return(result); } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_network_error, 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); } }
protected override async Task GetSegment(Stream stream, AsyncWrappingCommonArgs async) { var requested = SegmentSize; try { await _database.Xdr.Write(IscCodes.op_get_segment, async).ConfigureAwait(false); await _database.Xdr.Write(_blobHandle, async).ConfigureAwait(false); await _database.Xdr.Write(requested < short.MaxValue - 12?requested : short.MaxValue - 12, async).ConfigureAwait(false); await _database.Xdr.Write(DataSegment, async).ConfigureAwait(false); await _database.Xdr.Flush(async).ConfigureAwait(false); var response = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false); RblRemoveValue(IscCodes.RBL_segment); if (response.ObjectHandle == 1) { RblAddValue(IscCodes.RBL_segment); } else if (response.ObjectHandle == 2) { RblAddValue(IscCodes.RBL_eof_pending); } var buffer = response.Data; if (buffer.Length == 0) { // previous segment was last, this has no data return; } var len = 0; var srcpos = 0; while (srcpos < buffer.Length) { len = (int)IscHelper.VaxInteger(buffer, srcpos, 2); srcpos += 2; stream.Write(buffer, srcpos, len); srcpos += len; } } catch (IOException ex) { throw IscException.ForIOException(ex); } }
public virtual void Attach(ServiceParameterBuffer spb, string dataSource, int port, string service, byte[] cryptKey) { try { SendAttachToBuffer(spb, service); _database.Xdr.Flush(); ProcessAttachResponse(_database.ReadResponse <GenericResponse>()); } catch (IOException ex) { _database.Detach(); throw IscException.ForErrorCode(IscCodes.isc_network_error, ex); } }
public override void Prepare(string commandText) { ClearAll(); try { if (State == StatementState.Deallocated) { SendAllocateToBuffer(); _database.Xdr.Flush(); ProcessAllocateResponce(_database.ReadResponse <GenericResponse>()); } SendPrepareToBuffer(commandText); _database.Xdr.Flush(); ProcessPrepareResponse(_database.ReadResponse <GenericResponse>()); SendInfoSqlToBuffer(StatementTypeInfoItems, IscCodes.STATEMENT_TYPE_BUFFER_SIZE); _database.Xdr.Flush(); StatementType = ProcessStatementTypeInfoBuffer(ProcessInfoSqlResponse(_database.ReadResponse <GenericResponse>())); State = StatementState.Prepared; } catch (IOException ex) { State = State == StatementState.Allocated ? StatementState.Error : State; throw IscException.ForErrorCode(IscCodes.isc_network_error, ex); } }
public override void Attach(ServiceParameterBufferBase spb, string dataSource, int port, string service, byte[] cryptKey) { try { SendAttachToBuffer(spb, service); _database.Xdr.Flush(); ProcessAttachResponse((GenericResponse)_database.ReadResponse()); } catch (IOException ex) { _database.Detach(); throw IscException.ForIOException(ex); } }
public void Start(ServiceParameterBuffer spb) { lock (this) { try { _database.Write(IscCodes.op_service_start); _database.Write(Handle); _database.Write(0); _database.WriteBuffer(spb.ToArray(), spb.Length); _database.Flush(); try { _database.ReadResponse(); } catch (IscException) { throw; } } catch (IOException) { throw new IscException(IscCodes.isc_net_write_err); } } }
public virtual async Task Attach(ServiceParameterBuffer spb, string dataSource, int port, string service, byte[] cryptKey, AsyncWrappingCommonArgs async) { try { await SendAttachToBuffer(spb, service, async).ConfigureAwait(false); await _database.Xdr.Flush(async).ConfigureAwait(false); await ProcessAttachResponse((GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false), async).ConfigureAwait(false); } catch (IOException ex) { await _database.Detach(async).ConfigureAwait(false); throw IscException.ForErrorCode(IscCodes.isc_network_error, ex); } }
protected override void PutSegment(byte[] buffer) { try { _database.XdrStream.Write(IscCodes.op_batch_segments); _database.XdrStream.Write(_blobHandle); _database.XdrStream.WriteBlobBuffer(buffer); _database.XdrStream.Flush(); _database.ReadResponse(); } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_net_read_err, 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); } }
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 = _database.ReadResponse <GenericResponse>(); _database.TransactionCount++; _handle = response.ObjectHandle; _state = TransactionState.Active; } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_network_error, ex); } }
protected override void PutSegment(byte[] buffer) { lock (_database.SyncObject) { try { _database.Write(IscCodes.op_batch_segments); _database.Write(_blobHandle); _database.WriteBlobBuffer(buffer); _database.Flush(); _database.ReadResponse(); } catch (IOException) { throw new IscException(IscCodes.isc_net_read_err); } } }
public void Commit() { lock (_stateSyncRoot) { CheckTransactionState(); try { lock (_database.SyncObject) { _database.Write(IscCodes.op_commit); _database.Write(_handle); _database.Flush(); _database.ReadResponse(); _database.TransactionCount--; } if (Update != null) { Update(this, new EventArgs()); } _state = TransactionState.NoTransaction; } catch (IOException) { throw new IscException(IscCodes.isc_net_read_err); } } }
public override void Commit() { lock (_stateSyncRoot) { EnsureActiveTransactionState(); try { lock (_database.SyncObject) { _database.XdrStream.Write(IscCodes.op_commit); _database.XdrStream.Write(_handle); _database.XdrStream.Flush(); _database.ReadResponse(); _database.TransactionCount--; } Update?.Invoke(this, new EventArgs()); _state = TransactionState.NoTransaction; } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex); } } }
private void ThreadHandler(object o) { try { while (GetEventsCountLocked() > 0) { var operation = _database.NextOperation(); switch (operation) { case IscCodes.op_response: _database.ReadResponse(); continue; case IscCodes.op_exit: case IscCodes.op_disconnect: Close(); return; case IscCodes.op_event: var dbHandle = _database.ReadInt32(); var buffer = _database.ReadBuffer(); var ast = _database.ReadBytes(8); var eventId = _database.ReadInt32(); RemoteEvent currentEvent; if (_events.TryRemove(eventId, out currentEvent)) { // Notify new event counts currentEvent.EventCounts(buffer); } continue; } } } catch (ThreadAbortException) { return; } catch { return; } }
private void ThreadHandler(object _) { try { while (_events.Any()) { var operation = _database.NextOperation(); switch (operation) { case IscCodes.op_response: _database.ReadResponse(); continue; case IscCodes.op_exit: case IscCodes.op_disconnect: Close(); return; case IscCodes.op_event: var dbHandle = _database.XdrStream.ReadInt32(); var buffer = _database.XdrStream.ReadBuffer(); var ast = _database.XdrStream.ReadBytes(8); var eventId = _database.XdrStream.ReadInt32(); RemoteEvent currentEvent; if (_events.TryRemove(eventId, out currentEvent)) { // Notify new event counts currentEvent.EventCounts(buffer); } continue; } } } catch (IOException ex) when((ex.InnerException as SocketException)?.SocketErrorCode == SocketError.Interrupted) { return; } }
protected override void Seek(int position) { lock (this.database.SyncObject) { try { this.database.Write(IscCodes.op_seek_blob); this.database.Write(this.blobHandle); this.database.Write(0); // Seek mode this.database.Write(position); // Seek offset this.database.Flush(); GenericResponse response = (GenericResponse)database.ReadResponse(); this.position = response.ObjectHandle; } catch (IOException) { throw new IscException(IscCodes.isc_network_error); } } }
public void Start(ServiceParameterBuffer spb) { try { _database.XdrStream.Write(IscCodes.op_service_start); _database.XdrStream.Write(Handle); _database.XdrStream.Write(0); _database.XdrStream.WriteBuffer(spb.ToArray(), spb.Length); _database.XdrStream.Flush(); try { _database.ReadResponse(); } catch (IscException) { throw; } } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_net_write_err, ex); } }
private byte[] ReceiveSliceResponse(ArrayDesc desc) { try { int operation = _database.ReadOperation(); if (operation == IscCodes.op_slice) { bool isVariying = false; int elements = 0; int length = _database.XdrStream.ReadInt32(); length = _database.XdrStream.ReadInt32(); switch (desc.DataType) { case IscCodes.blr_text: case IscCodes.blr_text2: case IscCodes.blr_cstring: case IscCodes.blr_cstring2: elements = length / desc.Length; length += elements * ((4 - desc.Length) & 3); break; case IscCodes.blr_varying: case IscCodes.blr_varying2: elements = length / desc.Length; isVariying = true; break; case IscCodes.blr_short: length = length * desc.Length; break; } if (isVariying) { using (XdrStream xdr = new XdrStream()) { for (int i = 0; i < elements; i++) { byte[] buffer = _database.XdrStream.ReadOpaque(_database.XdrStream.ReadInt32()); xdr.WriteBuffer(buffer, buffer.Length); } return(xdr.ToArray()); } } else { return(_database.XdrStream.ReadOpaque(length)); } } else { _database.SetOperation(operation); _database.ReadResponse(); return(null); } } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex); } }
public override DbValueBase[] Fetch() { if (_state == StatementState.Deallocated) { throw new InvalidOperationException("Statement is not correctly created."); } if (_statementType != DbStatementType.Select && _statementType != DbStatementType.SelectForUpdate) { return(null); } if (!_allRowsFetched && _rows.Count == 0) { try { _database.XdrStream.Write(IscCodes.op_fetch); _database.XdrStream.Write(_handle); _database.XdrStream.WriteBuffer(_fields.ToBlrArray()); _database.XdrStream.Write(0); // p_sqldata_message_number _database.XdrStream.Write(_fetchSize); // p_sqldata_messages _database.XdrStream.Flush(); if (_database.NextOperation() == IscCodes.op_fetch_response) { IResponse response = null; while (!_allRowsFetched) { response = _database.ReadResponse(); if (response is FetchResponse) { FetchResponse fetchResponse = (FetchResponse)response; if (fetchResponse.Count > 0 && fetchResponse.Status == 0) { var row = AllocNewRow(); ReadRow(row); _rows.Enqueue(row); } else if (fetchResponse.Status == 100) { _allRowsFetched = true; } else { break; } } else { break; } } } else { _database.ReadResponse(); } } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex); } } if (_rows != null && _rows.Count > 0) { var result = _rows.Dequeue(); if (!_allRowsFetched) { if (_bufferedRows == null) { _bufferedRows = new Stack <DbValueBase[]>(); } _bufferedRows.Push(result); } return(result); } else { _rows.Clear(); return(null); } }
public override DbValue[] Fetch() { if (_state == StatementState.Deallocated) { throw new InvalidOperationException("Statement is not correctly created."); } if (_statementType != DbStatementType.Select && _statementType != DbStatementType.SelectForUpdate) { return(null); } if (!_allRowsFetched && _rows.Count == 0) { // Fetch next batch of rows lock (_database.SyncObject) { try { _database.Write(IscCodes.op_fetch); _database.Write(_handle); _database.WriteBuffer(_fields.ToBlrArray()); _database.Write(0); // p_sqldata_message_number _database.Write(_fetchSize); // p_sqldata_messages _database.Flush(); if (_database.NextOperation() == IscCodes.op_fetch_response) { IResponse response = null; while (!_allRowsFetched) { response = _database.ReadResponse(); if (response is FetchResponse) { FetchResponse fetchResponse = (FetchResponse)response; if (fetchResponse.Count > 0 && fetchResponse.Status == 0) { _rows.Enqueue(ReadDataRow()); } else if (fetchResponse.Status == 100) { _allRowsFetched = true; } else { break; } } else { break; } } } else { _database.ReadResponse(); } } catch (IOException) { throw new IscException(IscCodes.isc_net_read_err); } } } if (_rows != null && _rows.Count > 0) { return(_rows.Dequeue()); } else { _rows.Clear(); return(null); } }
public override DbValue[] Fetch() { if (_state == StatementState.Deallocated) { throw new InvalidOperationException("Statement is not correctly created."); } if (_statementType == DbStatementType.StoredProcedure && !_allRowsFetched) { _allRowsFetched = true; return(GetOutputParameters()); } else if (_statementType == DbStatementType.Insert && _allRowsFetched) { return(null); } else if (_statementType != DbStatementType.Select && _statementType != DbStatementType.SelectForUpdate) { return(null); } if (!_allRowsFetched && _rows.Count == 0) { try { _database.XdrStream.Write(IscCodes.op_fetch); _database.XdrStream.Write(_handle); _database.XdrStream.WriteBuffer(_fields.ToBlrArray()); _database.XdrStream.Write(0); // p_sqldata_message_number _database.XdrStream.Write(_fetchSize); // p_sqldata_messages _database.XdrStream.Flush(); if (_database.NextOperation() == IscCodes.op_fetch_response) { IResponse response = null; while (!_allRowsFetched) { response = _database.ReadResponse(); if (response is FetchResponse fetchResponse) { if (fetchResponse.Count > 0 && fetchResponse.Status == 0) { _rows.Enqueue(ReadRow()); } else if (fetchResponse.Status == 100) { _allRowsFetched = true; } else { break; } } else { break; } } } else { _database.ReadResponse(); } } catch (IOException ex) { throw IscException.ForErrorCode(IscCodes.isc_network_error, ex); } } if (_rows != null && _rows.Count > 0) { return(_rows.Dequeue()); } else { _rows.Clear(); return(null); } }