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