internal Task <FbTransaction> BeginTransactionImpl(IsolationLevel level, string transactionName, AsyncWrappingCommonArgs async)
{
CheckClosed();
return(_innerConnection.BeginTransaction(level, transactionName, async));
}
private Task DisposeImpl(AsyncWrappingCommonArgs async)
{
return(_connection.Disconnect(async));
}
protected virtual Task ProcessAttachResponse(GenericResponse response, AsyncWrappingCommonArgs async)
{
_handle = response.ObjectHandle;
return(Task.CompletedTask);
}
private async Task DatabaseShutdown2Impl(FbShutdownOnlineMode mode, FbShutdownType type, int seconds, AsyncWrappingCommonArgs async)
{
EnsureDatabase();
await Open(async).ConfigureAwait(false);
var startSpb = new ServiceParameterBuffer();
startSpb.Append(IscCodes.isc_action_svc_properties);
startSpb.Append(IscCodes.isc_spb_dbname, Database, SpbFilenameEncoding);
startSpb.Append(IscCodes.isc_spb_prp_shutdown_mode, FbShutdownOnlineModeToIscCode(mode));
switch (type)
{
case FbShutdownType.ForceShutdown:
startSpb.Append(IscCodes.isc_spb_prp_force_shutdown, seconds);
break;
case FbShutdownType.AttachmentsShutdown:
startSpb.Append(IscCodes.isc_spb_prp_attachments_shutdown, seconds);
break;
case FbShutdownType.TransactionsShutdown:
startSpb.Append(IscCodes.isc_spb_prp_transactions_shutdown, seconds);
break;
}
await StartTask(startSpb, async).ConfigureAwait(false);
await Close(async).ConfigureAwait(false);
}
public override async Task Prepare(string commandText, AsyncWrappingCommonArgs async)
{
ClearAll();
try
{
var numberOfResponses = 0;
if (State == StatementState.Deallocated)
{
await SendAllocateToBuffer(async).ConfigureAwait(false);
numberOfResponses++;
}
await SendPrepareToBuffer(commandText, async).ConfigureAwait(false);
numberOfResponses++;
await SendInfoSqlToBuffer(StatementTypeInfoItems, IscCodes.STATEMENT_TYPE_BUFFER_SIZE, async).ConfigureAwait(false);
numberOfResponses++;
await _database.Xdr.Flush(async).ConfigureAwait(false);
try
{
GenericResponse allocateResponse = null;
if (State == StatementState.Deallocated)
{
numberOfResponses--;
allocateResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
}
numberOfResponses--;
var prepareResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
var deferredExecute = ((prepareResponse.ObjectHandle & IscCodes.STMT_DEFER_EXECUTE) == IscCodes.STMT_DEFER_EXECUTE);
numberOfResponses--;
var statementTypeResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
if (allocateResponse != null)
{
await ProcessAllocateResponse(allocateResponse, async).ConfigureAwait(false);
}
await ProcessPrepareResponse(prepareResponse, async).ConfigureAwait(false);
StatementType = ProcessStatementTypeInfoBuffer(await ProcessInfoSqlResponse(statementTypeResponse, async).ConfigureAwait(false));
}
finally
{
numberOfResponses = await SafeFinishFetching(numberOfResponses, async).ConfigureAwait(false);
}
State = StatementState.Prepared;
}
catch (IOException ex)
{
State = State == StatementState.Allocated ? StatementState.Error : State;
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public Task <FbTransaction> BeginTransaction(System.Transactions.IsolationLevel isolationLevel, AsyncWrappingCommonArgs async)
{
var il = isolationLevel switch
{
System.Transactions.IsolationLevel.Chaos => IsolationLevel.Chaos,
System.Transactions.IsolationLevel.ReadUncommitted => IsolationLevel.ReadUncommitted,
System.Transactions.IsolationLevel.RepeatableRead => IsolationLevel.RepeatableRead,
System.Transactions.IsolationLevel.Serializable => IsolationLevel.Serializable,
System.Transactions.IsolationLevel.Snapshot => IsolationLevel.Snapshot,
System.Transactions.IsolationLevel.Unspecified => IsolationLevel.Unspecified,
_ => IsolationLevel.ReadCommitted,
};
return(BeginTransaction(il, null, async));
}
protected override Task Seek(int position, AsyncWrappingCommonArgs async)
{
throw new NotSupportedException();
}
private static async Task CreateDatabaseImpl(string connectionString, int pageSize, bool forcedWrites, bool overwrite, AsyncWrappingCommonArgs async)
{
var options = new ConnectionString(connectionString);
options.Validate();
try
{
var db = new FbConnectionInternal(options);
try
{
await db.CreateDatabase(pageSize, forcedWrites, overwrite, async).ConfigureAwait(false);
}
finally
{
await db.Disconnect(async).ConfigureAwait(false);
}
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
private Task DisableCancelImpl(AsyncWrappingCommonArgs async)
{
CheckClosed();
return(_innerConnection.DisableCancel(async));
}
private Task <DataTable> GetSchemaImpl(string collectionName, string[] restrictions, AsyncWrappingCommonArgs async)
{
CheckClosed();
return(_innerConnection.GetSchema(collectionName, restrictions, async));
}
internal async Task OpenImpl(AsyncWrappingCommonArgs async)
{
if (string.IsNullOrEmpty(_connectionString))
{
throw new InvalidOperationException("Connection String is not initialized.");
}
if (!IsClosed && _state != ConnectionState.Connecting)
{
throw new InvalidOperationException("Connection already Open.");
}
try
{
OnStateChange(_state, ConnectionState.Connecting);
var createdNew = default(bool);
if (_options.Pooling)
{
_innerConnection = FbConnectionPoolManager.Instance.Get(_options, out createdNew);
}
else
{
_innerConnection = new FbConnectionInternal(_options);
createdNew = true;
}
if (createdNew)
{
try
{
await _innerConnection.Connect(async).ConfigureAwait(false);
}
catch (OperationCanceledException ex)
{
async.CancellationToken.ThrowIfCancellationRequested();
throw new TimeoutException("Timeout while connecting.", ex);
}
catch
{
if (_options.Pooling)
{
FbConnectionPoolManager.Instance.Release(_innerConnection, false);
}
throw;
}
}
_innerConnection.SetOwningConnection(this);
if (_options.Enlist)
{
try
{
EnlistTransaction(System.Transactions.Transaction.Current);
}
catch
{
// if enlistment fails clean up innerConnection
await _innerConnection.DisposeTransaction(async).ConfigureAwait(false);
if (_options.Pooling)
{
FbConnectionPoolManager.Instance.Release(_innerConnection, true);
}
else
{
await _innerConnection.Disconnect(async).ConfigureAwait(false);
_innerConnection = null;
}
throw;
}
}
// Bind Warning messages event
_innerConnection.Database.WarningMessage = OnWarningMessage;
// Update the connection state
OnStateChange(_state, ConnectionState.Open);
}
catch (IscException ex)
{
OnStateChange(_state, ConnectionState.Closed);
throw FbException.Create(ex);
}
catch
{
OnStateChange(_state, ConnectionState.Closed);
throw;
}
}
private Task <DataTable> GetSchemaImpl(string collectionName, AsyncWrappingCommonArgs async)
{
return(GetSchemaImpl(collectionName, null, async));
}
private Task <DataTable> GetSchemaImpl(AsyncWrappingCommonArgs async)
{
return(GetSchemaImpl("MetaDataCollections", async));
}
internal Task <FbTransaction> BeginTransactionImpl(FbTransactionOptions options, string transactionName, AsyncWrappingCommonArgs async)
{
CheckClosed();
return(_innerConnection.BeginTransaction(options, transactionName, async));
}
public async Task CreateDatabase(int pageSize, bool forcedWrites, bool overwrite, AsyncWrappingCommonArgs async)
{
var db = await ClientFactory.CreateDatabase(_options, async).ConfigureAwait(false);
var dpb = db.CreateDatabaseParameterBuffer();
dpb.Append(IscCodes.isc_dpb_dummy_packet_interval, new byte[] { 120, 10, 0, 0 });
dpb.Append(IscCodes.isc_dpb_sql_dialect, new byte[] { _options.Dialect, 0, 0, 0 });
if (!string.IsNullOrEmpty(_options.UserID))
{
dpb.Append(IscCodes.isc_dpb_user_name, _options.UserID);
}
if (_options.Charset.Length > 0)
{
var charset = Charset.GetCharset(_options.Charset);
if (charset == null)
{
throw new ArgumentException("Character set is not valid.");
}
else
{
dpb.Append(IscCodes.isc_dpb_set_db_charset, charset.Name);
}
}
dpb.Append(IscCodes.isc_dpb_force_write, (short)(forcedWrites ? 1 : 0));
dpb.Append(IscCodes.isc_dpb_overwrite, (overwrite ? 1 : 0));
if (pageSize > 0)
{
dpb.Append(IscCodes.isc_dpb_page_size, pageSize);
}
try
{
if (string.IsNullOrEmpty(_options.UserID) && string.IsNullOrEmpty(_options.Password))
{
await db.CreateDatabaseWithTrustedAuth(dpb, _options.DataSource, _options.Port, _options.Database, _options.CryptKey, async).ConfigureAwait(false);
}
else
{
await db.CreateDatabase(dpb, _options.DataSource, _options.Port, _options.Database, _options.CryptKey, async).ConfigureAwait(false);
}
}
finally
{
await db.Detach(async).ConfigureAwait(false);
}
}
private Task CancelCommandImpl(AsyncWrappingCommonArgs async)
{
CheckClosed();
return(_innerConnection.CancelCommand(async));
}
public async Task <FbTransaction> BeginTransaction(FbTransactionOptions options, string transactionName, AsyncWrappingCommonArgs async)
{
EnsureActiveTransaction();
try
{
_activeTransaction = new FbTransaction(_owningConnection, IsolationLevel.Unspecified);
await _activeTransaction.BeginTransaction(options, async).ConfigureAwait(false);
if (transactionName != null)
{
_activeTransaction.Save(transactionName);
}
}
catch (IscException ex)
{
await DisposeTransaction(async).ConfigureAwait(false);
throw new FbException(ex.Message, ex);
}
return(_activeTransaction);
}
internal async Task BeginTransaction(FbTransactionOptions options, AsyncWrappingCommonArgs async)
{
_transaction = await _connection.InnerConnection.Database.BeginTransaction(BuildTpb(options), async).ConfigureAwait(false);
}
public Task <DataTable> GetSchema(string collectionName, string[] restrictions, AsyncWrappingCommonArgs async)
{
return(FbSchemaFactory.GetSchema(_owningConnection, collectionName, restrictions, async));
}
public override Task <ArrayBase> CreateArray(ArrayDesc descriptor, AsyncWrappingCommonArgs async)
{
var array = new FesArray(descriptor);
return(Task.FromResult((ArrayBase)array));
}
protected override Task <Array> DecodeSlice(byte[] slice, AsyncWrappingCommonArgs async)
{
Array sliceData = null;
var slicePosition = 0;
var type = 0;
var dbType = DbDataType.Array;
var systemType = GetSystemType();
var charset = _db.Charset;
var lengths = new int[Descriptor.Dimensions];
var lowerBounds = new int[Descriptor.Dimensions];
for (var i = 0; i < Descriptor.Dimensions; i++)
{
lowerBounds[i] = Descriptor.Bounds[i].LowerBound;
lengths[i] = Descriptor.Bounds[i].UpperBound;
if (lowerBounds[i] == 0)
{
lengths[i]++;
}
}
sliceData = Array.CreateInstance(systemType, lengths, lowerBounds);
var tempData = Array.CreateInstance(systemType, sliceData.Length);
type = TypeHelper.GetSqlTypeFromBlrType(Descriptor.DataType);
dbType = TypeHelper.GetDbDataTypeFromBlrType(Descriptor.DataType, 0, Descriptor.Scale);
int itemLength = Descriptor.Length;
for (var i = 0; i < tempData.Length; i++)
{
if (slicePosition >= slice.Length)
{
break;
}
switch (dbType)
{
case DbDataType.Char:
tempData.SetValue(charset.GetString(slice, slicePosition, itemLength), i);
break;
case DbDataType.VarChar:
{
var index = slicePosition;
var count = 0;
while (slice[index++] != 0)
{
count++;
}
tempData.SetValue(charset.GetString(slice, slicePosition, count), i);
slicePosition += 2;
}
break;
case DbDataType.SmallInt:
tempData.SetValue(BitConverter.ToInt16(slice, slicePosition), i);
break;
case DbDataType.Integer:
tempData.SetValue(BitConverter.ToInt32(slice, slicePosition), i);
break;
case DbDataType.BigInt:
tempData.SetValue(BitConverter.ToInt64(slice, slicePosition), i);
break;
case DbDataType.Decimal:
case DbDataType.Numeric:
{
object evalue = null;
switch (type)
{
case IscCodes.SQL_SHORT:
evalue = BitConverter.ToInt16(slice, slicePosition);
break;
case IscCodes.SQL_LONG:
evalue = BitConverter.ToInt32(slice, slicePosition);
break;
case IscCodes.SQL_QUAD:
case IscCodes.SQL_INT64:
evalue = BitConverter.ToInt64(slice, slicePosition);
break;
}
var dvalue = TypeDecoder.DecodeDecimal(evalue, Descriptor.Scale, type);
tempData.SetValue(dvalue, i);
}
break;
case DbDataType.Double:
tempData.SetValue(BitConverter.ToDouble(slice, slicePosition), i);
break;
case DbDataType.Float:
tempData.SetValue(BitConverter.ToSingle(slice, slicePosition), i);
break;
case DbDataType.Date:
{
var idate = BitConverter.ToInt32(slice, slicePosition);
var date = TypeDecoder.DecodeDate(idate);
tempData.SetValue(date, i);
}
break;
case DbDataType.Time:
{
var itime = BitConverter.ToInt32(slice, slicePosition);
var time = TypeDecoder.DecodeTime(itime);
tempData.SetValue(time, i);
}
break;
case DbDataType.TimeStamp:
{
var idate = BitConverter.ToInt32(slice, slicePosition);
var itime = BitConverter.ToInt32(slice, slicePosition + 4);
var date = TypeDecoder.DecodeDate(idate);
var time = TypeDecoder.DecodeTime(itime);
var timestamp = date.Add(time);
tempData.SetValue(timestamp, i);
}
break;
}
slicePosition += itemLength;
}
if (systemType.GetTypeInfo().IsPrimitive)
{
// For primitive types we can use System.Buffer to copy generated data to destination array
Buffer.BlockCopy(tempData, 0, sliceData, 0, Buffer.ByteLength(tempData));
}
else
{
sliceData = tempData;
}
return(Task.FromResult(sliceData));
}
public override async Task <ArrayBase> CreateArray(long handle, string tableName, string fieldName, AsyncWrappingCommonArgs async)
{
var array = new FesArray(_db, _transaction, handle, tableName, fieldName);
await array.Initialize(async).ConfigureAwait(false);
return(array);
}
public override async Task Execute(AsyncWrappingCommonArgs async)
{
EnsureNotDeallocated();
Clear();
try
{
RecordsAffected = -1;
await SendExecuteToBuffer(async).ConfigureAwait(false);
var readRowsAffectedResponse = false;
if (DoRecordsAffected)
{
await SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE, async).ConfigureAwait(false);
readRowsAffectedResponse = true;
}
await _database.Xdr.Flush(async).ConfigureAwait(false);
var numberOfResponses = (StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1 + (readRowsAffectedResponse ? 1 : 0);
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = (SqlResponse)await _database.ReadResponse(async).ConfigureAwait(false);
await ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse, async).ConfigureAwait(false);
}
numberOfResponses--;
var executeResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
GenericResponse rowsAffectedResponse = null;
if (readRowsAffectedResponse)
{
numberOfResponses--;
rowsAffectedResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
}
await ProcessExecuteResponse(executeResponse, async).ConfigureAwait(false);
if (readRowsAffectedResponse)
{
RecordsAffected = ProcessRecordsAffectedBuffer(await ProcessInfoSqlResponse(rowsAffectedResponse, async).ConfigureAwait(false));
}
}
finally
{
numberOfResponses = await SafeFinishFetching(numberOfResponses, async).ConfigureAwait(false);
}
State = StatementState.Executed;
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override Task Close(AsyncWrappingCommonArgs async)
{
XsqldaMarshaler.CleanUpNativeData(ref _fetchSqlDa);
return(base.Close(async));
}
public async Task <DataTable> GetSchema(FbConnection connection, string collectionName, string[] restrictions, AsyncWrappingCommonArgs async)
{
var dataTable = new DataTable(collectionName);
var command = BuildCommand(connection, collectionName, ParseRestrictions(restrictions));
try
{
using (var adapter = new FbDataAdapter(command))
{
try
{
adapter.Fill(dataTable);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
}
}
finally
{
#if NET48 || NETSTANDARD2_0
command.Dispose();
await Task.CompletedTask.ConfigureAwait(false);
#else
await async.AsyncSyncCallNoCancellation(command.DisposeAsync, command.Dispose).ConfigureAwait(false);
#endif
}
TrimStringFields(dataTable);
ProcessResult(dataTable);
return(dataTable);
}
public override async Task Execute(AsyncWrappingCommonArgs async)
{
EnsureNotDeallocated();
ClearStatusVector();
var inSqlda = IntPtr.Zero;
var outSqlda = IntPtr.Zero;
if (_parameters != null)
{
inSqlda = await XsqldaMarshaler.MarshalManagedToNative(_db.Charset, _parameters, async).ConfigureAwait(false);
}
if (StatementType == DbStatementType.StoredProcedure)
{
Fields.ResetValues();
outSqlda = await XsqldaMarshaler.MarshalManagedToNative(_db.Charset, _fields, async).ConfigureAwait(false);
}
var trHandle = _transaction.HandlePtr;
_db.FbClient.isc_dsql_execute2(
_statusVector,
ref trHandle,
ref _handle,
IscCodes.SQLDA_VERSION1,
inSqlda,
outSqlda);
if (outSqlda != IntPtr.Zero)
{
var descriptor = XsqldaMarshaler.MarshalNativeToManaged(_db.Charset, outSqlda, true);
var values = new DbValue[descriptor.Count];
for (var i = 0; i < values.Length; i++)
{
var d = descriptor[i];
var value = await d.DbValue.GetValue(async).ConfigureAwait(false);
values[i] = new DbValue(this, d, value);
}
OutputParameters.Enqueue(values);
}
XsqldaMarshaler.CleanUpNativeData(ref inSqlda);
XsqldaMarshaler.CleanUpNativeData(ref outSqlda);
_db.ProcessStatusVector(_statusVector);
if (DoRecordsAffected)
{
RecordsAffected = await GetRecordsAffected(async).ConfigureAwait(false);
}
else
{
RecordsAffected = -1;
}
State = StatementState.Executed;
}
protected virtual async Task SendAttachToBuffer(DatabaseParameterBufferBase dpb, string database, AsyncWrappingCommonArgs async)
{
await Xdr.Write(IscCodes.op_attach, async).ConfigureAwait(false);
await Xdr.Write(0, async).ConfigureAwait(false);
if (!string.IsNullOrEmpty(Password))
{
dpb.Append(IscCodes.isc_dpb_password, Password);
}
await Xdr.WriteBuffer(Encoding.Default.GetBytes(database), async).ConfigureAwait(false);
await Xdr.WriteBuffer(dpb.ToArray(), async).ConfigureAwait(false);
}
public override async Task <DbValue[]> Fetch(AsyncWrappingCommonArgs async)
{
EnsureNotDeallocated();
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);
}
DbValue[] row = null;
if (!_allRowsFetched)
{
_fields.ResetValues();
if (_fetchSqlDa == IntPtr.Zero)
{
_fetchSqlDa = await XsqldaMarshaler.MarshalManagedToNative(_db.Charset, _fields, async).ConfigureAwait(false);
}
ClearStatusVector();
var status = _db.FbClient.isc_dsql_fetch(_statusVector, ref _handle, IscCodes.SQLDA_VERSION1, _fetchSqlDa);
var rowDesc = XsqldaMarshaler.MarshalNativeToManaged(_db.Charset, _fetchSqlDa, true);
if (_fields.Count == rowDesc.Count)
{
for (var i = 0; i < _fields.Count; i++)
{
if (_fields[i].IsArray() && _fields[i].ArrayHandle != null)
{
rowDesc[i].ArrayHandle = _fields[i].ArrayHandle;
}
}
}
_fields = rowDesc;
_db.ProcessStatusVector(_statusVector);
if (status == new IntPtr(100))
{
_allRowsFetched = true;
XsqldaMarshaler.CleanUpNativeData(ref _fetchSqlDa);
}
else
{
row = new DbValue[_fields.ActualCount];
for (var i = 0; i < row.Length; i++)
{
var d = _fields[i];
var value = await d.DbValue.GetValue(async).ConfigureAwait(false);
row[i] = new DbValue(this, d, value);
}
}
}
return(row);
}
protected async Task AfterAttachActions(AsyncWrappingCommonArgs async)
{
ServerVersion = await GetServerVersion(async).ConfigureAwait(false);
}
protected override async Task SendCreateToBuffer(DatabaseParameterBufferBase dpb, string database, AsyncWrappingCommonArgs async)
{
await Xdr.Write(IscCodes.op_create, async).ConfigureAwait(false);
await Xdr.Write(0, async).ConfigureAwait(false);
if (AuthData != null)
{
dpb.Append(IscCodes.isc_dpb_specific_auth_data, AuthData);
}
dpb.Append(IscCodes.isc_dpb_utf8_filename, 0);
await Xdr.WriteBuffer(Encoding.UTF8.GetBytes(database), async).ConfigureAwait(false);
await Xdr.WriteBuffer(dpb.ToArray(), async).ConfigureAwait(false);
}
