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