public virtual void CreateDatabase(DatabaseParameterBuffer dpb, string dataSource, int port, string database, byte[] cryptKey)
{
try
{
SendCreateToBuffer(dpb, database);
XdrStream.Flush();
ProcessCreateResponse(ReadGenericResponse());
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public virtual void ReleaseObject(int op, int id)
{
try
{
DoReleaseObjectPacket(op, id);
XdrStream.Flush();
ProcessReleaseObjectResponse(ReadResponse());
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override void CancelOperation(int kind)
{
try
{
SendCancelOperationToBuffer(kind);
XdrStream.Flush();
// no response, this is async
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public virtual void Detach()
{
if (TransactionCount > 0)
{
throw IscException.ForErrorCodeIntParam(IscCodes.isc_open_trans, TransactionCount);
}
try
{
CloseEventManager();
var detach = _handle != -1;
if (detach)
{
Xdr.Write(IscCodes.op_detach);
Xdr.Write(_handle);
}
Xdr.Write(IscCodes.op_disconnect);
Xdr.Flush();
if (detach)
{
ReadResponse();
}
CloseConnection();
}
catch (IOException ex)
{
try
{
CloseConnection();
}
catch (IOException ex2)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex2);
}
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
finally
{
_connection = null;
_charset = null;
_eventManager = null;
_serverVersion = null;
_dialect = 0;
_handle = -1;
_packetSize = 0;
_warningMessage = null;
_transactionCount = 0;
}
}
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 virtual async Task ReleaseObject(int op, int id, AsyncWrappingCommonArgs async)
{
try
{
await SendReleaseObjectToBuffer(op, id, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
await ProcessReleaseObjectResponse(await ReadResponse(async).ConfigureAwait(false), async).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public virtual async Task CreateDatabase(DatabaseParameterBufferBase dpb, string dataSource, int port, string database, byte[] cryptKey, AsyncWrappingCommonArgs async)
{
try
{
await SendCreateToBuffer(dpb, database, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
await ProcessCreateResponse((GenericResponse)await ReadResponse(async).ConfigureAwait(false), async).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected void ProcessStoredProcedureExecuteResponse(SqlResponse response)
{
try
{
if (response.Count > 0)
{
_outputParams.Enqueue(ReadRow());
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected async Task ProcessStoredProcedureExecuteResponse(SqlResponse response, AsyncWrappingCommonArgs async)
{
try
{
if (response.Count > 0)
{
_outputParams.Enqueue(await ReadRow(async).ConfigureAwait(false));
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected override void GetSegment(Stream stream)
{
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;
}
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.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override void Execute()
{
if (_state == StatementState.Deallocated)
{
throw new InvalidOperationException("Statement is not correctly created.");
}
// Clear data
Clear();
lock (_database.SyncObject)
{
try
{
RecordsAffected = -1;
SendExecuteToBuffer();
_database.XdrStream.Flush();
if (_statementType == DbStatementType.StoredProcedure)
{
ProcessStoredProcedureExecuteResponse(_database.ReadSqlResponse());
}
GenericResponse executeResponse = _database.ReadGenericResponse();
ProcessExecuteResponse(executeResponse);
// Updated number of records affected by the statement execution
if (ReturnRecordsAffected &&
(StatementType == DbStatementType.Insert ||
StatementType == DbStatementType.Delete ||
StatementType == DbStatementType.Update ||
StatementType == DbStatementType.StoredProcedure))
{
SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE);
_database.XdrStream.Flush();
RecordsAffected = ProcessRecordsAffectedBuffer(ProcessInfoSqlResponse(_database.ReadGenericResponse()));
}
_state = StatementState.Executed;
}
catch (IOException ex)
{
_state = StatementState.Error;
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public override void CreateDatabase(DatabaseParameterBuffer dpb, string dataSource, int port, string database, byte[] cryptKey)
{
try
{
SendCreateToBuffer(dpb, database);
Xdr.Flush();
var response = ReadResponse();
response = ProcessCryptCallbackResponseIfNeeded(response, cryptKey);
ProcessCreateResponse(response as GenericResponse);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override async Task CancelOperation(int kind, AsyncWrappingCommonArgs async)
{
try
{
await SendCancelOperationToBuffer(kind, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
// no response, this is async
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override void ReleaseObject(int op, int id)
{
lock (SyncObject)
{
try
{
DoReleaseObjectPacket(op, id);
DeferredPackets.Enqueue(ProcessReleaseObjectResponse);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
protected override async Task <byte[]> WriteParameters(AsyncWrappingCommonArgs async)
{
if (_parameters == null)
{
return(null);
}
using (var ms = new MemoryStream())
{
try
{
var xdr = new XdrReaderWriter(ms, _database.Charset);
var bits = new BitArray(_parameters.Count);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
bits.Set(i, await field.DbValue.IsDBNull(async).ConfigureAwait(false));
}
var buffer = new byte[(int)Math.Ceiling(_parameters.Count / 8d)];
for (var i = 0; i < buffer.Length * 8; i++)
{
var index = i / 8;
// LSB
buffer[index] = (byte)((buffer[index] >> 1) | (bits.Length > i && bits[i] ? 1 << 7 : 0));
}
await xdr.WriteOpaque(buffer, async).ConfigureAwait(false);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
if (await field.DbValue.IsDBNull(async).ConfigureAwait(false))
{
continue;
}
await WriteRawParameter(xdr, field, async).ConfigureAwait(false);
}
await xdr.Flush(async).ConfigureAwait(false);
return(ms.ToArray());
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
}
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 void ProcessStoredProcedureExecuteResponse(SqlResponse response)
{
try
{
if (response.Count > 0)
{
var row = AllocNewRow();
ReadRow(row);
_outputParams.Enqueue(row);
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
protected override void PutSegment(byte[] buffer)
{
try
{
_database.Xdr.Write(IscCodes.op_batch_segments);
_database.Xdr.Write(_blobHandle);
_database.Xdr.WriteBlobBuffer(buffer);
_database.Xdr.Flush();
_database.ReadResponse();
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override void Attach(ServiceParameterBuffer spb, string dataSource, int port, string service, byte[] cryptKey)
{
try
{
SendAttachToBuffer(spb, service);
Database.XdrStream.Flush();
var response = Database.ReadResponse();
response = (Database as GdsDatabase).ProcessCryptCallbackResponseIfNeeded(response, cryptKey);
ProcessAttachResponse(response as GenericResponse);
}
catch (IOException ex)
{
Database.Detach();
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public void CancelEvents(RemoteEvent events)
{
try
{
Xdr.Write(IscCodes.op_cancel_events);
Xdr.Write(_handle);
Xdr.Write(events.LocalId);
Xdr.Flush();
ReadResponse();
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public virtual void DropDatabase()
{
try
{
Xdr.Write(IscCodes.op_drop_database);
Xdr.Write(_handle);
Xdr.Flush();
ReadResponse();
_handle = -1;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public virtual void Detach()
{
if (TransactionCount > 0)
{
throw IscException.ForErrorCodeIntParam(IscCodes.isc_open_trans, TransactionCount);
}
try
{
CloseEventManager();
if (_handle != 0)
{
XdrStream.Write(IscCodes.op_detach);
XdrStream.Write(_handle);
}
XdrStream.Write(IscCodes.op_disconnect);
XdrStream.Flush();
CloseConnection();
#warning Here
_xdrStream?.Dispose();
_transactionCount = 0;
_handle = 0;
_dialect = 0;
_packetSize = 0;
_xdrStream = null;
_charset = null;
_connection = null;
_serverVersion = null;
}
catch (IOException ex)
{
try
{
CloseConnection();
}
catch (IOException ex2)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex2);
}
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected override ArraySegment <byte> WriteParameters()
{
if (_parameters == null)
{
return(new ArraySegment <byte>());
}
using (var stream = new MemoryStream())
{
var xdr = new XdrBinaryWriter(stream, _database.Charset);
try
{
var bits = new BitArray(_parameters.Count);
for (int i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
bits.Set(i, field.DbValue.IsDBNull());
}
var buffer = new byte[(int)Math.Ceiling(_parameters.Count / 8d)];
for (int i = 0; i < buffer.Length * 8; i++)
{
var index = i / 8;
// LSB
buffer[index] = (byte)((buffer[index] >> 1) | (bits.Length > i && bits[i] ? 1 << 7 : 0));
}
xdr.WriteOpaque(buffer);
for (var i = 0; i < _parameters.Count; i++)
{
var field = _parameters[i];
if (field.DbValue.IsDBNull())
{
continue;
}
WriteRawParameter(xdr, field);
}
return(stream.ToArraySegment());
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_write_err, ex);
}
}
}
public void QueueEvents(RemoteEvent events)
{
if (_eventManager == null)
{
string ipAddress = string.Empty;
int portNumber = 0;
int auxHandle = 0;
ConnectionRequest(out auxHandle, out ipAddress, out portNumber);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
}
lock (SyncObject)
{
try
{
events.LocalId = Interlocked.Increment(ref _eventsId);
// Enqueue events in the event manager
_eventManager.QueueEvents(events);
EventParameterBuffer epb = events.ToEpb();
XdrStream.Write(IscCodes.op_que_events);
XdrStream.Write(_handle); // Database object id
XdrStream.WriteBuffer(epb.ToArray()); // Event description block
XdrStream.Write(0); // Address of ast routine
XdrStream.Write(0); // Argument to ast routine
XdrStream.Write(events.LocalId); // Client side id of remote event
XdrStream.Flush();
GenericResponse response = (GenericResponse)ReadResponse();
// Update event Remote event ID
events.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public override void RollbackRetaining()
{
EnsureActiveTransactionState();
try
{
_database.Xdr.Write(IscCodes.op_rollback_retaining);
_database.Xdr.Write(_handle);
_database.Xdr.Flush();
_database.ReadResponse();
_state = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected override async Task PutSegment(byte[] buffer, AsyncWrappingCommonArgs async)
{
try
{
await _database.Xdr.Write(IscCodes.op_batch_segments, async).ConfigureAwait(false);
await _database.Xdr.Write(_blobHandle, async).ConfigureAwait(false);
await _database.Xdr.WriteBlobBuffer(buffer, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
await _database.ReadResponse(async).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public virtual async Task DropDatabase(AsyncWrappingCommonArgs async)
{
try
{
await Xdr.Write(IscCodes.op_drop_database, async).ConfigureAwait(false);
await Xdr.Write(_handle, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
await ReadResponse(async).ConfigureAwait(false);
_handle = -1;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected override void Seek(int position)
{
try
{
_database.Xdr.Write(IscCodes.op_seek_blob);
_database.Xdr.Write(_blobHandle);
_database.Xdr.Write(SeekMode);
_database.Xdr.Write(position);
_database.Xdr.Flush();
var response = (GenericResponse)_database.ReadResponse();
_position = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public async Task CancelEvents(RemoteEvent events, AsyncWrappingCommonArgs async)
{
try
{
await Xdr.Write(IscCodes.op_cancel_events, async).ConfigureAwait(false);
await Xdr.Write(_handle, async).ConfigureAwait(false);
await Xdr.Write(events.LocalId, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
await ReadResponse(async).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override void CommitRetaining()
{
EnsureActiveTransactionState();
try
{
_database.XdrStream.Write(IscCodes.op_commit_retaining);
_database.XdrStream.Write(_handle);
_database.XdrStream.Flush();
_database.ReadResponse();
_state = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
