public override async ValueTask <TransactionBase> BeginTransactionAsync(TransactionParameterBuffer tpb, CancellationToken cancellationToken = default)
{
var transaction = new FesTransaction(this);
await transaction.BeginTransactionAsync(tpb, cancellationToken).ConfigureAwait(false);
return(transaction);
}
public override async Task <TransactionBase> BeginTransaction(TransactionParameterBuffer tpb, AsyncWrappingCommonArgs async)
{
var transaction = new FesTransaction(this);
await transaction.BeginTransaction(tpb, async).ConfigureAwait(false);
return(transaction);
}
public void BeginTransaction(TransactionParameterBuffer tpb)
{
lock (this.db)
{
if (this.state != TransactionState.NoTransaction)
{
throw new IscException(
IscCodes.isc_arg_gds,
IscCodes.isc_tra_state,
this.handle,
"no valid");
}
this.state = TransactionState.TrasactionStarting;
try
{
this.db.Send.Write(IscCodes.op_transaction);
this.db.Send.Write(this.db.Handle);
this.db.Send.WriteBuffer(tpb.ToArray());
this.db.Send.Flush();
this.handle = db.ReadGenericResponse().ObjectHandle;
this.state = TransactionState.TransactionStarted;
this.db.TransactionCount++;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
private TransactionParameterBuffer BuildTpb(IsolationLevel isolationLevel)
{
TransactionParameterBuffer tpb = this.db.CreateTransactionParameterBuffer();
tpb.Append(IscCodes.isc_tpb_version3);
tpb.Append(IscCodes.isc_tpb_write);
tpb.Append(IscCodes.isc_tpb_wait);
/* Isolation level */
switch (isolationLevel)
{
case IsolationLevel.Serializable:
tpb.Append(IscCodes.isc_tpb_consistency);
break;
case IsolationLevel.RepeatableRead:
tpb.Append(IscCodes.isc_tpb_concurrency);
break;
case IsolationLevel.ReadUncommitted:
tpb.Append(IscCodes.isc_tpb_read_committed);
tpb.Append(IscCodes.isc_tpb_rec_version);
break;
case IsolationLevel.ReadCommitted:
default:
tpb.Append(IscCodes.isc_tpb_read_committed);
tpb.Append(IscCodes.isc_tpb_no_rec_version);
break;
}
return(tpb);
}
public override void BeginTransaction(TransactionParameterBuffer tpb)
{
if (_state != TransactionState.NoTransaction)
{
throw new InvalidOperationException();
}
IscTeb teb = new IscTeb();
IntPtr tebData = IntPtr.Zero;
try
{
ClearStatusVector();
teb.dbb_ptr = Marshal.AllocHGlobal(4);
Marshal.WriteInt32(teb.dbb_ptr, _db.Handle);
teb.tpb_len = tpb.Length;
teb.tpb_ptr = Marshal.AllocHGlobal(tpb.Length);
Marshal.Copy(tpb.ToArray(), 0, teb.tpb_ptr, tpb.Length);
int size = Marshal2.SizeOf <IscTeb>();
tebData = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(teb, tebData, true);
_db.FbClient.isc_start_multiple(
_statusVector,
ref _handle,
1,
tebData);
_db.ProcessStatusVector(_statusVector);
_state = TransactionState.Active;
_db.TransactionCount++;
}
catch
{
throw;
}
finally
{
if (teb.dbb_ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(teb.dbb_ptr);
}
if (teb.tpb_ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(teb.tpb_ptr);
}
if (tebData != IntPtr.Zero)
{
Marshal2.DestroyStructure <IscTeb>(tebData);
Marshal.FreeHGlobal(tebData);
}
}
}
public override TransactionBase BeginTransaction(TransactionParameterBuffer tpb)
{
var transaction = new FesTransaction(this);
transaction.BeginTransaction(tpb);
return(transaction);
}
public void BeginTransaction(TransactionParameterBuffer tpb)
{
if (this.state != TransactionState.NoTransaction)
{
throw new IscException(IscCodes.isc_arg_gds, IscCodes.isc_tra_state, this.handle, "no valid");
}
lock (this.database.SyncObject)
{
try
{
this.database.Write(IscCodes.op_transaction);
this.database.Write(this.database.Handle);
this.database.WriteBuffer(tpb.ToArray());
this.database.Flush();
GenericResponse response = this.database.ReadGenericResponse();
this.handle = response.ObjectHandle;
this.state = TransactionState.Active;
this.database.TransactionCount++;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public void BeginTransaction(TransactionParameterBuffer tpb)
{
lock (stateSyncRoot)
{
if (this.state != TransactionState.NoTransaction)
{
throw GetNoValidTransactionException();
}
try
{
GenericResponse response;
lock (this.database.SyncObject)
{
this.database.Write(IscCodes.op_transaction);
this.database.Write(this.database.Handle);
this.database.WriteBuffer(tpb.ToArray());
this.database.Flush();
response = this.database.ReadGenericResponse();
this.database.TransactionCount++;
}
this.handle = response.ObjectHandle;
this.state = TransactionState.Active;
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
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);
}
}
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)
{
lock (_stateSyncRoot)
{
if (_state != TransactionState.NoTransaction)
{
throw new InvalidOperationException();
}
try
{
GenericResponse response;
lock (_database.SyncObject)
{
_database.XdrStream.Write(IscCodes.op_transaction);
_database.XdrStream.Write(_database.Handle);
_database.XdrStream.WriteBuffer(tpb.ToArray());
_database.XdrStream.Flush();
response = _database.ReadGenericResponse();
_database.TransactionCount++;
}
_handle = response.ObjectHandle;
_state = TransactionState.Active;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, 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 virtual TransactionBase BeginTransaction(TransactionParameterBuffer tpb)
{
var transaction = new GdsTransaction(this);
transaction.BeginTransaction(tpb);
return(transaction);
}
public TransactionBase BeginTransaction(TransactionParameterBuffer tpb)
{
FesTransaction transaction = new FesTransaction(this);
transaction.BeginTransaction(tpb);
return(transaction);
}
public ITransaction BeginTransaction(TransactionParameterBuffer tpb)
{
GdsTransaction transaction = new GdsTransaction(this);
transaction.BeginTransaction(tpb);
return(transaction);
}
public override ValueTask BeginTransactionAsync(TransactionParameterBuffer tpb, CancellationToken cancellationToken = default)
{
if (State != TransactionState.NoTransaction)
{
throw new InvalidOperationException();
}
var teb = new IscTeb();
var tebData = IntPtr.Zero;
try
{
ClearStatusVector();
teb.dbb_ptr = Marshal.AllocHGlobal(4);
Marshal.WriteInt32(teb.dbb_ptr, _db.Handle);
teb.tpb_len = tpb.Length;
teb.tpb_ptr = Marshal.AllocHGlobal(tpb.Length);
Marshal.Copy(tpb.ToArray(), 0, teb.tpb_ptr, tpb.Length);
var size = Marshal.SizeOf <IscTeb>();
tebData = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(teb, tebData, true);
_db.FbClient.isc_start_multiple(
_statusVector,
ref _handle,
1,
tebData);
_db.ProcessStatusVector(_statusVector);
State = TransactionState.Active;
_db.TransactionCount++;
}
finally
{
if (teb.dbb_ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(teb.dbb_ptr);
}
if (teb.tpb_ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(teb.tpb_ptr);
}
if (tebData != IntPtr.Zero)
{
Marshal.DestroyStructure <IscTeb>(tebData);
Marshal.FreeHGlobal(tebData);
}
}
return(ValueTask2.CompletedTask);
}
public void BeginTransaction(TransactionParameterBuffer tpb)
{
// Clear the status vector
this.ClearStatusVector();
int trHandle = 0;
lock (this.db)
{
SafeNativeMethods.isc_get_current_transaction(this.statusVector, ref trHandle);
this.handle = trHandle;
this.state = TransactionState.Active;
}
}
public override void BeginTransaction(TransactionParameterBuffer tpb)
{
if (_state != TransactionState.NoTransaction)
{
throw new InvalidOperationException();
}
lock (_db)
{
IscTeb teb = new IscTeb();
IntPtr tebData = IntPtr.Zero;
try
{
// Clear the status vector
ClearStatusVector();
// Set db handle
teb.dbb_ptr = Marshal.AllocHGlobal(4);
Marshal.WriteInt32(teb.dbb_ptr, _db.Handle);
// Set tpb length
teb.tpb_len = tpb.Length;
// Set TPB data
teb.tpb_ptr = Marshal.AllocHGlobal(tpb.Length);
Marshal.Copy(tpb.ToArray(), 0, teb.tpb_ptr, tpb.Length);
// Alloc memory for the IscTeb structure
int size = Marshal.SizeOf(typeof(IscTeb));
tebData = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(teb, tebData, true);
_db.FbClient.isc_start_multiple(
_statusVector,
ref _handle,
1,
tebData);
// Parse status vector
_db.ProcessStatusVector(_statusVector);
// Update transaction state
_state = TransactionState.Active;
// Update transaction count
_db.TransactionCount++;
}
catch
{
throw;
}
finally
{
// Free memory
if (teb.dbb_ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(teb.dbb_ptr);
}
if (teb.tpb_ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(teb.tpb_ptr);
}
if (tebData != IntPtr.Zero)
{
Marshal.DestroyStructure(tebData, typeof(IscTeb));
Marshal.FreeHGlobal(tebData);
}
}
}
}
private TransactionParameterBuffer BuildTpb(FbTransactionOptions options)
{
TransactionParameterBuffer tpb = new TransactionParameterBuffer();
tpb.Append(IscCodes.isc_tpb_version3);
FbTransactionOptions[] o = (FbTransactionOptions[])Enum.GetValues(options.GetType());
for (int i = 0; i < o.Length; i++)
{
FbTransactionOptions option = ((FbTransactionOptions)(o[i]));
if ((options & option) == option)
{
switch (option)
{
case FbTransactionOptions.Consistency:
tpb.Append(IscCodes.isc_tpb_consistency);
break;
case FbTransactionOptions.Concurrency:
tpb.Append(IscCodes.isc_tpb_concurrency);
break;
case FbTransactionOptions.Shared:
tpb.Append(IscCodes.isc_tpb_shared);
break;
case FbTransactionOptions.Protected:
tpb.Append(IscCodes.isc_tpb_protected);
break;
case FbTransactionOptions.Exclusive:
tpb.Append(IscCodes.isc_tpb_exclusive);
break;
case FbTransactionOptions.Wait:
tpb.Append(IscCodes.isc_tpb_wait);
break;
case FbTransactionOptions.NoWait:
tpb.Append(IscCodes.isc_tpb_nowait);
break;
case FbTransactionOptions.Read:
tpb.Append(IscCodes.isc_tpb_read);
break;
case FbTransactionOptions.Write:
tpb.Append(IscCodes.isc_tpb_write);
break;
case FbTransactionOptions.LockRead:
tpb.Append(IscCodes.isc_tpb_lock_read);
break;
case FbTransactionOptions.LockWrite:
tpb.Append(IscCodes.isc_tpb_lock_write);
break;
case FbTransactionOptions.ReadCommitted:
tpb.Append(IscCodes.isc_tpb_read_committed);
break;
case FbTransactionOptions.Autocommit:
tpb.Append(IscCodes.isc_tpb_autocommit);
break;
case FbTransactionOptions.RecVersion:
tpb.Append(IscCodes.isc_tpb_rec_version);
break;
case FbTransactionOptions.NoRecVersion:
tpb.Append(IscCodes.isc_tpb_no_rec_version);
break;
case FbTransactionOptions.RestartRequests:
tpb.Append(IscCodes.isc_tpb_restart_requests);
break;
case FbTransactionOptions.NoAutoUndo:
tpb.Append(IscCodes.isc_tpb_no_auto_undo);
break;
}
}
}
return(tpb);
}
private TransactionParameterBuffer BuildTpb(FbTransactionOptions options)
{
TransactionParameterBuffer tpb = new TransactionParameterBuffer();
tpb.Append(IscCodes.isc_tpb_version3);
if ((options & FbTransactionOptions.Consistency) == FbTransactionOptions.Consistency)
{
tpb.Append(IscCodes.isc_tpb_consistency);
}
if ((options & FbTransactionOptions.Concurrency) == FbTransactionOptions.Concurrency)
{
tpb.Append(IscCodes.isc_tpb_concurrency);
}
if ((options & FbTransactionOptions.Shared) == FbTransactionOptions.Shared)
{
tpb.Append(IscCodes.isc_tpb_shared);
}
if ((options & FbTransactionOptions.Protected) == FbTransactionOptions.Protected)
{
tpb.Append(IscCodes.isc_tpb_protected);
}
if ((options & FbTransactionOptions.Exclusive) == FbTransactionOptions.Exclusive)
{
tpb.Append(IscCodes.isc_tpb_exclusive);
}
if ((options & FbTransactionOptions.Wait) == FbTransactionOptions.Wait)
{
tpb.Append(IscCodes.isc_tpb_wait);
}
if ((options & FbTransactionOptions.NoWait) == FbTransactionOptions.NoWait)
{
tpb.Append(IscCodes.isc_tpb_nowait);
}
if ((options & FbTransactionOptions.Read) == FbTransactionOptions.Read)
{
tpb.Append(IscCodes.isc_tpb_read);
}
if ((options & FbTransactionOptions.Write) == FbTransactionOptions.Write)
{
tpb.Append(IscCodes.isc_tpb_write);
}
if ((options & FbTransactionOptions.LockRead) == FbTransactionOptions.LockRead)
{
tpb.Append(IscCodes.isc_tpb_lock_read);
}
if ((options & FbTransactionOptions.LockWrite) == FbTransactionOptions.LockWrite)
{
tpb.Append(IscCodes.isc_tpb_lock_write);
}
if ((options & FbTransactionOptions.ReadCommitted) == FbTransactionOptions.ReadCommitted)
{
tpb.Append(IscCodes.isc_tpb_read_committed);
}
if ((options & FbTransactionOptions.Autocommit) == FbTransactionOptions.Autocommit)
{
tpb.Append(IscCodes.isc_tpb_autocommit);
}
if ((options & FbTransactionOptions.RecVersion) == FbTransactionOptions.RecVersion)
{
tpb.Append(IscCodes.isc_tpb_rec_version);
}
if ((options & FbTransactionOptions.NoRecVersion) == FbTransactionOptions.NoRecVersion)
{
tpb.Append(IscCodes.isc_tpb_no_rec_version);
}
if ((options & FbTransactionOptions.RestartRequests) == FbTransactionOptions.RestartRequests)
{
tpb.Append(IscCodes.isc_tpb_restart_requests);
}
if ((options & FbTransactionOptions.NoAutoUndo) == FbTransactionOptions.NoAutoUndo)
{
tpb.Append(IscCodes.isc_tpb_no_auto_undo);
}
return(tpb);
}
public abstract TransactionBase BeginTransaction(TransactionParameterBuffer tpb);
public void BeginTransaction(TransactionParameterBuffer tpb)
{
if (this.state != TransactionState.NoTransaction)
{
throw new IscException(IscCodes.isc_arg_gds, IscCodes.isc_tra_state, this.handle, "no valid");
}
lock (this.db)
{
IscTeb teb = new IscTeb();
IntPtr tebData = IntPtr.Zero;
try
{
// Clear the status vector
this.ClearStatusVector();
// Set db handle
teb.dbb_ptr = Marshal.AllocHGlobal(4);
Marshal.WriteInt32(teb.dbb_ptr, this.db.Handle);
// Set tpb length
teb.tpb_len = tpb.Length;
// Set TPB data
teb.tpb_ptr = Marshal.AllocHGlobal(tpb.Length);
Marshal.Copy(tpb.ToArray(), 0, teb.tpb_ptr, tpb.Length);
// Alloc memory for the IscTeb structure
int size = Marshal.SizeOf(typeof(IscTeb));
tebData = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(teb, tebData, true);
int trHandle = this.handle;
db.FbClient.isc_start_multiple(
this.statusVector,
ref trHandle,
1,
tebData);
this.handle = trHandle;
// Parse status vector
this.db.ParseStatusVector(this.statusVector);
// Update transaction state
this.state = TransactionState.Active;
// Update transaction count
this.db.TransactionCount++;
}
catch (Exception)
{
throw;
}
finally
{
// Free memory
if (teb.dbb_ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(teb.dbb_ptr);
}
if (teb.tpb_ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(teb.tpb_ptr);
}
if (tebData != IntPtr.Zero)
{
Marshal.DestroyStructure(tebData, typeof(IscTeb));
Marshal.FreeHGlobal(tebData);
}
}
}
}
private static TransactionParameterBuffer BuildTpb(FbTransactionOptions options)
{
var tpb = new TransactionParameterBuffer();
tpb.Append(IscCodes.isc_tpb_version3);
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.Consistency))
{
tpb.Append(IscCodes.isc_tpb_consistency);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.Concurrency))
{
tpb.Append(IscCodes.isc_tpb_concurrency);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.Wait))
{
tpb.Append(IscCodes.isc_tpb_wait);
if (options.WaitTimeoutTPBValue.HasValue)
{
tpb.Append(IscCodes.isc_tpb_lock_timeout, (short)options.WaitTimeoutTPBValue);
}
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.NoWait))
{
tpb.Append(IscCodes.isc_tpb_nowait);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.Read))
{
tpb.Append(IscCodes.isc_tpb_read);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.Write))
{
tpb.Append(IscCodes.isc_tpb_write);
}
foreach (var table in options.LockTables)
{
int lockType;
if (table.Value.HasFlag(FbTransactionBehavior.LockRead))
{
lockType = IscCodes.isc_tpb_lock_read;
}
else if (table.Value.HasFlag(FbTransactionBehavior.LockWrite))
{
lockType = IscCodes.isc_tpb_lock_write;
}
else
{
throw new ArgumentException("Must specify either LockRead or LockWrite.");
}
tpb.Append(lockType, table.Key);
int?lockBehavior = null;
if (table.Value.HasFlag(FbTransactionBehavior.Exclusive))
{
lockBehavior = IscCodes.isc_tpb_exclusive;
}
else if (table.Value.HasFlag(FbTransactionBehavior.Protected))
{
lockBehavior = IscCodes.isc_tpb_protected;
}
else if (table.Value.HasFlag(FbTransactionBehavior.Shared))
{
lockBehavior = IscCodes.isc_tpb_shared;
}
if (lockBehavior.HasValue)
{
tpb.Append((int)lockBehavior);
}
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.ReadCommitted))
{
tpb.Append(IscCodes.isc_tpb_read_committed);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.Autocommit))
{
tpb.Append(IscCodes.isc_tpb_autocommit);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.RecVersion))
{
tpb.Append(IscCodes.isc_tpb_rec_version);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.NoRecVersion))
{
tpb.Append(IscCodes.isc_tpb_no_rec_version);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.RestartRequests))
{
tpb.Append(IscCodes.isc_tpb_restart_requests);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.NoAutoUndo))
{
tpb.Append(IscCodes.isc_tpb_no_auto_undo);
}
if (options.TransactionBehavior.HasFlag(FbTransactionBehavior.ReadConsistency))
{
tpb.Append(IscCodes.isc_tpb_read_consistency);
}
return(tpb);
}
public abstract void BeginTransaction(TransactionParameterBuffer tpb);
public abstract ValueTask BeginTransactionAsync(TransactionParameterBuffer tpb, CancellationToken cancellationToken = default);
