public void Connect()
{
if (Charset.GetCharset(_options.Charset) == null)
{
throw FbException.Create("Invalid character set specified");
}
try
{
_db = ClientFactory.CreateDatabase(_options);
_db.Charset = Charset.GetCharset(_options.Charset);
_db.Dialect = _options.Dialect;
_db.PacketSize = _options.PacketSize;
var dpb = BuildDpb(_db, _options);
if (string.IsNullOrEmpty(_options.UserID) && string.IsNullOrEmpty(_options.Password))
{
_db.AttachWithTrustedAuth(dpb, _options.Database, _options.CryptKey);
}
else
{
_db.Attach(dpb, _options.Database, _options.CryptKey);
}
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
private protected void Open()
{
if (State != FbServiceState.Closed)
{
throw new InvalidOperationException("Service already Open.");
}
if (string.IsNullOrEmpty(_options.UserID))
{
throw new InvalidOperationException("No user name was specified.");
}
if (string.IsNullOrEmpty(_options.Password))
{
throw new InvalidOperationException("No user password was specified.");
}
try
{
if (_svc == null)
{
_svc = ClientFactory.CreateServiceManager(_options);
}
_svc.Attach(BuildSpb(), _options.DataSource, _options.Port, ServiceName, _options.CryptKey);
_svc.WarningMessage = OnWarningMessage;
State = FbServiceState.Open;
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
}
private protected void EnsureDatabase()
{
if (string.IsNullOrEmpty(Database))
{
throw FbException.Create("Action should be executed against a specific database.");
}
}
public void Dispose()
{
if (!_disposed)
{
_disposed = true;
try
{
Release();
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
_multiError = false;
//_commandTimeout = 0;
//_fetchSize = 0;
_implicitTransaction = false;
_commandText = null;
_connection = null;
_transaction = null;
_batchParameters = null;
_statement = null;
//_activeReader = null;
_namedParameters = null;
}
}
public FbBatchNonQueryResult ExecuteNonQuery()
{
CheckCommand();
FbBatchNonQueryResult result;
using (var explicitCancellation = ExplicitCancellation.Enter(CancellationToken.None, Cancel))
{
try
{
result = ExecuteCommand(false);
//if (_statement.StatementType == DbStatementType.StoredProcedure)
//{
// SetOutputParameters();
//}
CommitImplicitTransaction();
}
catch (IscException ex)
{
RollbackImplicitTransaction();
throw FbException.Create(ex);
}
catch
{
RollbackImplicitTransaction();
throw;
}
}
return(result);
}
public void Execute()
{
EnsureDatabase();
try
{
Open();
var startSpb = new ServiceParameterBuffer2();
startSpb.Append(IscCodes.isc_action_svc_nbak);
startSpb.Append2(IscCodes.isc_spb_dbname, Database, SpbFilenameEncoding);
startSpb.Append(IscCodes.isc_spb_nbk_level, _level);
startSpb.Append2(IscCodes.isc_spb_nbk_file, BackupFile, SpbFilenameEncoding);
startSpb.Append2(IscCodes.isc_spb_nbk_direct, DirectIO ? "ON" : "OFF");
startSpb.Append(IscCodes.isc_spb_options, (int)Options);
StartTask(startSpb);
ProcessServiceOutput(ServiceParameterBufferBase.Empty);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
Close();
}
}
private FbBatchNonQueryResult ExecuteCommand(bool returnsSet)
{
LogCommandExecutionIfEnabled();
Prepare(returnsSet);
// Set the fetch size
//_statement.FetchSize = _fetchSize;
// Set if it's needed the Records Affected information
_statement.ReturnRecordsAffected = _connection.ConnectionOptions.ReturnRecordsAffected;
// Validate input parameter count
if (_namedParameters.Count > 0 && !HasParameters)
{
throw FbException.Create("Must declare command parameters.");
}
var batch = _statement.CreateBatch();
try
{
batch.MultiError = MultiError;
// Execute
return(new FbBatchNonQueryResult(batch.Execute(_batchParameters.Count, this)));
}
finally
{
batch.Dispose2();
}
}
private async Task ExecuteImpl(AsyncWrappingCommonArgs async)
{
EnsureDatabase();
try
{
await Open(async).ConfigureAwait(false);
var startSpb = new ServiceParameterBuffer();
startSpb.Append(IscCodes.isc_action_svc_backup);
startSpb.Append(IscCodes.isc_spb_dbname, Database, SpbFilenameEncoding);
startSpb.Append(IscCodes.isc_spb_bkp_file, "stdout", SpbFilenameEncoding);
if (!string.IsNullOrEmpty(SkipData))
{
startSpb.Append(IscCodes.isc_spb_bkp_skip_data, SkipData);
}
startSpb.Append(IscCodes.isc_spb_options, (int)Options);
await StartTask(startSpb, async).ConfigureAwait(false);
await ReadOutput(async).ConfigureAwait(false);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
await Close(async).ConfigureAwait(false);
}
}
private async Task StartImpl(string sessionName, AsyncWrappingCommonArgs async)
{
var version = _version;
if (version == FbTraceVersion.Detect)
{
version = DetectVersion();
}
try
{
var config = string.Join(Environment.NewLine, DatabasesConfigurations.BuildConfiguration(version), ServiceConfiguration?.BuildConfiguration(version) ?? string.Empty);
await Open(async).ConfigureAwait(false);
var startSpb = new ServiceParameterBuffer();
startSpb.Append(IscCodes.isc_action_svc_trace_start);
if (!string.IsNullOrEmpty(sessionName))
{
startSpb.Append(IscCodes.isc_spb_trc_name, sessionName);
}
startSpb.Append(IscCodes.isc_spb_trc_cfg, config);
await StartTask(startSpb, async).ConfigureAwait(false);
await ProcessServiceOutput(EmptySpb, async).ConfigureAwait(false);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
await Close(async).ConfigureAwait(false);
}
}
public void Execute()
{
EnsureDatabase();
try
{
Open();
var startSpb = new ServiceParameterBuffer2();
startSpb.Append(IscCodes.isc_action_svc_backup);
startSpb.Append2(IscCodes.isc_spb_dbname, Database, SpbFilenameEncoding);
startSpb.Append2(IscCodes.isc_spb_bkp_file, "stdout", SpbFilenameEncoding);
if (!string.IsNullOrEmpty(SkipData))
{
startSpb.Append2(IscCodes.isc_spb_bkp_skip_data, SkipData);
}
startSpb.Append(IscCodes.isc_spb_options, (int)Options);
StartTask(startSpb);
ReadOutput();
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
Close();
}
}
public async Task ExecuteAsync(CancellationToken cancellationToken = default)
{
EnsureDatabase();
try
{
await OpenAsync(cancellationToken).ConfigureAwait(false);
var startSpb = new ServiceParameterBuffer2();
startSpb.Append(IscCodes.isc_action_svc_backup);
startSpb.Append2(IscCodes.isc_spb_dbname, Database, SpbFilenameEncoding);
startSpb.Append2(IscCodes.isc_spb_bkp_file, "stdout", SpbFilenameEncoding);
if (!string.IsNullOrEmpty(SkipData))
{
startSpb.Append2(IscCodes.isc_spb_bkp_skip_data, SkipData);
}
startSpb.Append(IscCodes.isc_spb_options, (int)Options);
await StartTaskAsync(startSpb, cancellationToken).ConfigureAwait(false);
await ReadOutputAsync(cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
await CloseAsync(cancellationToken).ConfigureAwait(false);
}
}
public override async Task ChangeDatabaseAsync(string db, CancellationToken cancellationToken = default)
#endif
{
CheckClosed();
if (string.IsNullOrEmpty(db))
{
throw new InvalidOperationException("Database name is not valid.");
}
var oldConnectionString = _connectionString;
try
{
var csb = new FbConnectionStringBuilder(_connectionString);
/* Close current connection */
await CloseAsync().ConfigureAwait(false);
/* Set up the new Database */
csb.Database = db;
ConnectionString = csb.ToString();
/* Open new connection */
await OpenAsync(cancellationToken).ConfigureAwait(false);
}
catch (IscException ex)
{
ConnectionString = oldConnectionString;
throw FbException.Create(ex);
}
}
public override void ChangeDatabase(string db)
{
CheckClosed();
if (string.IsNullOrEmpty(db))
{
throw new InvalidOperationException("Database name is not valid.");
}
var oldConnectionString = _connectionString;
try
{
var csb = new FbConnectionStringBuilder(_connectionString);
/* Close current connection */
Close();
/* Set up the new Database */
csb.Database = db;
ConnectionString = csb.ToString();
/* Open new connection */
Open();
}
catch (IscException ex)
{
ConnectionString = oldConnectionString;
throw FbException.Create(ex);
}
}
public async Task ConnectAsync(CancellationToken cancellationToken = default)
{
if (Charset.GetCharset(_options.Charset) == null)
{
throw FbException.Create("Invalid character set specified");
}
try
{
_db = await ClientFactory.CreateDatabaseAsync(_options, cancellationToken).ConfigureAwait(false);
_db.Charset = Charset.GetCharset(_options.Charset);
_db.Dialect = _options.Dialect;
_db.PacketSize = _options.PacketSize;
var dpb = BuildDpb(_db, _options);
if (string.IsNullOrEmpty(_options.UserID) && string.IsNullOrEmpty(_options.Password))
{
await _db.AttachWithTrustedAuthAsync(dpb, _options.Database, _options.CryptKey, cancellationToken).ConfigureAwait(false);
}
else
{
await _db.AttachAsync(dpb, _options.Database, _options.CryptKey, cancellationToken).ConfigureAwait(false);
}
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
public override async ValueTask DisposeAsync()
{
if (!_disposed)
{
_disposed = true;
if (_transaction != null)
{
if (!_isCompleted)
{
try
{
await _transaction.Dispose2Async(CancellationToken.None).ConfigureAwait(false);
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
}
_connection = null;
_transaction = null;
_isCompleted = true;
}
await base.DisposeAsync().ConfigureAwait(false);
}
public DataTable GetSchema(FbConnection connection, string collectionName, string[] restrictions)
{
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();
#else
command.Dispose();
#endif
}
TrimStringFields(dataTable);
ProcessResult(dataTable);
return(dataTable);
}
protected override void Dispose(bool disposing)
{
if (!_disposed)
{
_disposed = true;
if (_transaction != null)
{
if (!_isCompleted)
{
try
{
_transaction.Dispose2();
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
}
_connection = null;
_transaction = null;
_isCompleted = true;
}
base.Dispose(disposing);
}
private async Task ExecuteImpl(AsyncWrappingCommonArgs async)
{
EnsureDatabase();
try
{
await Open(async).ConfigureAwait(false);
var startSpb = new ServiceParameterBuffer();
startSpb.Append(IscCodes.isc_action_svc_nbak);
startSpb.Append(IscCodes.isc_spb_dbname, Database, SpbFilenameEncoding);
startSpb.Append(IscCodes.isc_spb_nbk_level, _level);
startSpb.Append(IscCodes.isc_spb_nbk_file, BackupFile, SpbFilenameEncoding);
startSpb.Append(IscCodes.isc_spb_nbk_direct, DirectIO ? "ON" : "OFF");
startSpb.Append(IscCodes.isc_spb_options, (int)Options);
await StartTask(startSpb, async).ConfigureAwait(false);
await ProcessServiceOutput(EmptySpb, async).ConfigureAwait(false);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
await Close(async).ConfigureAwait(false);
}
}
public async Task ExecuteAsync(CancellationToken cancellationToken = default)
{
EnsureDatabase();
try
{
await OpenAsync(cancellationToken).ConfigureAwait(false);
var startSpb = new ServiceParameterBuffer2();
startSpb.Append(IscCodes.isc_action_svc_nbak);
startSpb.Append2(IscCodes.isc_spb_dbname, Database, SpbFilenameEncoding);
startSpb.Append(IscCodes.isc_spb_nbk_level, _level);
startSpb.Append2(IscCodes.isc_spb_nbk_file, BackupFile, SpbFilenameEncoding);
startSpb.Append2(IscCodes.isc_spb_nbk_direct, DirectIO ? "ON" : "OFF");
startSpb.Append(IscCodes.isc_spb_options, (int)Options);
await StartTaskAsync(startSpb, cancellationToken).ConfigureAwait(false);
await ProcessServiceOutputAsync(ServiceParameterBufferBase.Empty, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
await CloseAsync(cancellationToken).ConfigureAwait(false);
}
}
public void Start(string sessionName)
{
var version = _version;
if (version == FbTraceVersion.Detect)
{
version = DetectVersion();
}
try
{
var config = string.Join(Environment.NewLine, DatabasesConfigurations.BuildConfiguration(version), ServiceConfiguration?.BuildConfiguration(version) ?? string.Empty);
Open();
var startSpb = new ServiceParameterBuffer2();
startSpb.Append(IscCodes.isc_action_svc_trace_start);
if (!string.IsNullOrEmpty(sessionName))
{
startSpb.Append2(IscCodes.isc_spb_trc_name, sessionName);
}
startSpb.Append2(IscCodes.isc_spb_trc_cfg, config);
StartTask(startSpb);
ProcessServiceOutput(ServiceParameterBufferBase.Empty);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
Close();
}
}
private async Task <FbBatchNonQueryResult> ExecuteCommandAsync(bool returnsSet, CancellationToken cancellationToken = default)
{
LogCommandExecutionIfEnabled();
await PrepareAsync(returnsSet, cancellationToken).ConfigureAwait(false);
// Set the fetch size
//_statement.FetchSize = _fetchSize;
// Set if it's needed the Records Affected information
_statement.ReturnRecordsAffected = _connection.ConnectionOptions.ReturnRecordsAffected;
// Validate input parameter count
if (_namedParameters.Count > 0 && !HasParameters)
{
throw FbException.Create("Must declare command parameters.");
}
var batch = _statement.CreateBatch();
try
{
batch.MultiError = MultiError;
// Execute
return(new FbBatchNonQueryResult(await batch.ExecuteAsync(_batchParameters.Count, this, cancellationToken).ConfigureAwait(false)));
}
finally
{
await batch.Dispose2Async(cancellationToken).ConfigureAwait(false);
}
}
public async Task StartAsync(string sessionName, CancellationToken cancellationToken = default)
{
var version = _version;
if (version == FbTraceVersion.Detect)
{
version = await DetectVersionAsync(cancellationToken).ConfigureAwait(false);
}
try
{
var config = string.Join(Environment.NewLine, DatabasesConfigurations.BuildConfiguration(version), ServiceConfiguration?.BuildConfiguration(version) ?? string.Empty);
await OpenAsync(cancellationToken).ConfigureAwait(false);
var startSpb = new ServiceParameterBuffer2();
startSpb.Append(IscCodes.isc_action_svc_trace_start);
if (!string.IsNullOrEmpty(sessionName))
{
startSpb.Append2(IscCodes.isc_spb_trc_name, sessionName);
}
startSpb.Append2(IscCodes.isc_spb_trc_cfg, config);
await StartTaskAsync(startSpb, cancellationToken).ConfigureAwait(false);
await ProcessServiceOutputAsync(ServiceParameterBufferBase.Empty, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
finally
{
await CloseAsync(cancellationToken).ConfigureAwait(false);
}
}
public async ValueTask DisposeAsync()
{
if (!_disposed)
{
_disposed = true;
try
{
await ReleaseAsync(CancellationToken.None).ConfigureAwait(false);
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
_multiError = false;
//_commandTimeout = 0;
//_fetchSize = 0;
_implicitTransaction = false;
_commandText = null;
_connection = null;
_transaction = null;
_batchParameters = null;
_statement = null;
//_activeReader = null;
_namedParameters = null;
}
}
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 async Task <FbBatchNonQueryResult> ExecuteNonQueryAsync(CancellationToken cancellationToken = default)
{
CheckCommand();
FbBatchNonQueryResult result;
using (var explicitCancellation = ExplicitCancellation.Enter(cancellationToken, Cancel))
{
try
{
result = await ExecuteCommandAsync(false, explicitCancellation.CancellationToken).ConfigureAwait(false);
//if (_statement.StatementType == DbStatementType.StoredProcedure)
//{
// await SetOutputParametersAsync(explicitCancellation.CancellationToken).ConfigureAwait(false);
//}
await CommitImplicitTransactionAsync(explicitCancellation.CancellationToken).ConfigureAwait(false);
}
catch (IscException ex)
{
await RollbackImplicitTransactionAsync(explicitCancellation.CancellationToken).ConfigureAwait(false);
throw FbException.Create(ex);
}
catch
{
await RollbackImplicitTransactionAsync(explicitCancellation.CancellationToken).ConfigureAwait(false);
throw;
}
}
return(result);
}
private protected async Task OpenAsync(CancellationToken cancellationToken = default)
{
if (State != FbServiceState.Closed)
{
throw new InvalidOperationException("Service already Open.");
}
if (string.IsNullOrEmpty(_options.UserID))
{
throw new InvalidOperationException("No user name was specified.");
}
if (string.IsNullOrEmpty(_options.Password))
{
throw new InvalidOperationException("No user password was specified.");
}
try
{
if (_svc == null)
{
_svc = await ClientFactory.CreateServiceManagerAsync(_options, cancellationToken).ConfigureAwait(false);
}
await _svc.AttachAsync(BuildSpb(), _options.DataSource, _options.Port, ServiceName, _options.CryptKey, cancellationToken).ConfigureAwait(false);
_svc.WarningMessage = OnWarningMessage;
State = FbServiceState.Open;
}
catch (Exception ex)
{
throw FbException.Create(ex);
}
}
internal FbBatchNonQueryResult(ExecuteResultItem[] result)
{
_items = result.Select(x => new FbBatchNonQueryResultItem()
{
RecordsAffected = x.RecordsAffected,
IsSuccess = !x.IsError,
Exception = x.Exception != null ? (FbException)FbException.Create(x.Exception) : null,
}).ToList();
}
public void CancelEvents()
{
try
{
_revent.CancelEvents();
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
public async Task CancelEventsAsync(CancellationToken cancellationToken = default)
{
try
{
await _revent.CancelEventsAsync(cancellationToken).ConfigureAwait(false);
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}
private static T CheckedGetValue2 <T>(Func <T> getter)
{
try
{
return(getter());
}
catch (IscException ex)
{
throw FbException.Create(ex);
}
}