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);
}
private async Task DisposeCommand(AsyncWrappingCommonArgs async)
{
if (_sqlCommand != null)
{
#if NET48 || NETSTANDARD2_0
_sqlCommand.Dispose();
await Task.CompletedTask.ConfigureAwait(false);
#else
await async.AsyncSyncCallNoCancellation(_sqlCommand.DisposeAsync, _sqlCommand.Dispose).ConfigureAwait(false);
#endif
}
}
public async Task DisposeTransaction(AsyncWrappingCommonArgs async)
{
if (_activeTransaction != null && !IsEnlisted)
{
#if NET48 || NETSTANDARD2_0
_activeTransaction.Dispose();
await Task.CompletedTask.ConfigureAwait(false);
#else
await async.AsyncSyncCallNoCancellation(_activeTransaction.DisposeAsync, _activeTransaction.Dispose).ConfigureAwait(false);
#endif
_activeTransaction = null;
}
}
private async Task RollbackTransaction(AsyncWrappingCommonArgs async)
{
if (_sqlTransaction != null)
{
await _sqlTransaction.RollbackImpl(async).ConfigureAwait(false);
#if NET48 || NETSTANDARD2_0
_sqlTransaction.Dispose();
#else
await async.AsyncSyncCallNoCancellation(_sqlTransaction.DisposeAsync, _sqlTransaction.Dispose).ConfigureAwait(false);
#endif
_sqlTransaction = null;
}
}
private async Task ExecuteImpl(bool autoCommit, AsyncWrappingCommonArgs async)
{
if ((_statements?.Count ?? 0) == 0)
{
throw new InvalidOperationException("There are no commands for execution.");
}
_shouldClose = false;
foreach (var statement in Statements)
{
if (!(statement.StatementType == SqlStatementType.Connect ||
statement.StatementType == SqlStatementType.CreateDatabase ||
statement.StatementType == SqlStatementType.Disconnect ||
statement.StatementType == SqlStatementType.DropDatabase ||
statement.StatementType == SqlStatementType.SetAutoDDL ||
statement.StatementType == SqlStatementType.SetDatabase ||
statement.StatementType == SqlStatementType.SetNames ||
statement.StatementType == SqlStatementType.SetSQLDialect))
{
await ProvideCommand(async).ConfigureAwait(false);
_sqlCommand.CommandText = statement.Text;
if (_sqlTransaction == null && !(statement.StatementType == SqlStatementType.Commit || statement.StatementType == SqlStatementType.Rollback))
{
_sqlTransaction = await _sqlConnection.BeginTransactionImpl(FbTransaction.DefaultIsolationLevel, null, async).ConfigureAwait(false);
}
_sqlCommand.Transaction = _sqlTransaction;
}
try
{
switch (statement.StatementType)
{
case SqlStatementType.AlterCharacterSet:
case SqlStatementType.AlterDatabase:
case SqlStatementType.AlterDomain:
case SqlStatementType.AlterException:
case SqlStatementType.AlterFunction:
case SqlStatementType.AlterIndex:
case SqlStatementType.AlterPackage:
case SqlStatementType.AlterProcedure:
case SqlStatementType.AlterRole:
case SqlStatementType.AlterSequence:
case SqlStatementType.AlterTable:
case SqlStatementType.AlterTrigger:
case SqlStatementType.AlterView:
case SqlStatementType.CommentOn:
case SqlStatementType.CreateCollation:
case SqlStatementType.CreateDomain:
case SqlStatementType.CreateException:
case SqlStatementType.CreateFunction:
case SqlStatementType.CreateGenerator:
case SqlStatementType.CreateIndex:
case SqlStatementType.CreatePackage:
case SqlStatementType.CreatePackageBody:
case SqlStatementType.CreateProcedure:
case SqlStatementType.CreateRole:
case SqlStatementType.CreateSequence:
case SqlStatementType.CreateShadow:
case SqlStatementType.CreateTable:
case SqlStatementType.CreateTrigger:
case SqlStatementType.CreateView:
case SqlStatementType.DeclareCursor:
case SqlStatementType.DeclareExternalFunction:
case SqlStatementType.DeclareFilter:
case SqlStatementType.DeclareStatement:
case SqlStatementType.DeclareTable:
case SqlStatementType.Delete:
case SqlStatementType.DropCollation:
case SqlStatementType.DropDomain:
case SqlStatementType.DropException:
case SqlStatementType.DropExternalFunction:
case SqlStatementType.DropFunction:
case SqlStatementType.DropFilter:
case SqlStatementType.DropGenerator:
case SqlStatementType.DropIndex:
case SqlStatementType.DropPackage:
case SqlStatementType.DropPackageBody:
case SqlStatementType.DropProcedure:
case SqlStatementType.DropSequence:
case SqlStatementType.DropRole:
case SqlStatementType.DropShadow:
case SqlStatementType.DropTable:
case SqlStatementType.DropTrigger:
case SqlStatementType.DropView:
case SqlStatementType.EventInit:
case SqlStatementType.EventWait:
case SqlStatementType.Execute:
case SqlStatementType.ExecuteImmediate:
case SqlStatementType.ExecuteProcedure:
case SqlStatementType.Grant:
case SqlStatementType.Insert:
case SqlStatementType.InsertCursor:
case SqlStatementType.Merge:
case SqlStatementType.Open:
case SqlStatementType.Prepare:
case SqlStatementType.Revoke:
case SqlStatementType.RecreateFunction:
case SqlStatementType.RecreatePackage:
case SqlStatementType.RecreatePackageBody:
case SqlStatementType.RecreateProcedure:
case SqlStatementType.RecreateTable:
case SqlStatementType.RecreateTrigger:
case SqlStatementType.RecreateView:
case SqlStatementType.SetGenerator:
case SqlStatementType.Update:
case SqlStatementType.Whenever:
OnCommandExecuting(_sqlCommand, statement.StatementType);
var rowsAffected = await ExecuteCommand(autoCommit, async).ConfigureAwait(false);
_requiresNewConnection = false;
OnCommandExecuted(null, statement.Text, statement.StatementType, rowsAffected);
break;
case SqlStatementType.ExecuteBlock:
case SqlStatementType.Select:
(await ProvideCommand(async).ConfigureAwait(false)).CommandText = statement.Text;
OnCommandExecuting(_sqlCommand, statement.StatementType);
var dataReader = await _sqlCommand.ExecuteReaderImpl(CommandBehavior.Default, async).ConfigureAwait(false);
try
{
_requiresNewConnection = false;
OnCommandExecuted(dataReader, statement.Text, statement.StatementType, -1);
}
finally
{
#if NET48 || NETSTANDARD2_0
dataReader.Dispose();
#else
await async.AsyncSyncCallNoCancellation(dataReader.DisposeAsync, dataReader.Dispose).ConfigureAwait(false);
#endif
}
break;
case SqlStatementType.Commit:
OnCommandExecuting(null, statement.StatementType);
await CommitTransaction(async).ConfigureAwait(false);
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.Rollback:
OnCommandExecuting(null, statement.StatementType);
await RollbackTransaction(async).ConfigureAwait(false);
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.CreateDatabase:
OnCommandExecuting(null, statement.StatementType);
await CreateDatabase(statement.CleanText, async).ConfigureAwait(false);
_requiresNewConnection = false;
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.DropDatabase:
OnCommandExecuting(null, statement.StatementType);
await async.AsyncSyncCall(FbConnection.DropDatabaseAsync, FbConnection.DropDatabase, _connectionString.ToString()).ConfigureAwait(false);
_requiresNewConnection = true;
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.Connect:
OnCommandExecuting(null, statement.StatementType);
await ConnectToDatabase(statement.CleanText, async).ConfigureAwait(false);
_requiresNewConnection = false;
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.Disconnect:
OnCommandExecuting(null, statement.StatementType);
await _sqlConnection.CloseImpl(async).ConfigureAwait(false);
FbConnection.ClearPool(_sqlConnection);
_requiresNewConnection = false;
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.SetAutoDDL:
OnCommandExecuting(null, statement.StatementType);
SetAutoDdl(statement.CleanText, ref autoCommit);
_requiresNewConnection = false;
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.SetNames:
OnCommandExecuting(null, statement.StatementType);
SetNames(statement.CleanText);
_requiresNewConnection = true;
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.SetSQLDialect:
OnCommandExecuting(null, statement.StatementType);
SetSqlDialect(statement.CleanText);
_requiresNewConnection = true;
OnCommandExecuted(null, statement.Text, statement.StatementType, -1);
break;
case SqlStatementType.Fetch:
case SqlStatementType.Describe:
break;
case SqlStatementType.SetDatabase:
case SqlStatementType.SetStatistics:
case SqlStatementType.SetTransaction:
case SqlStatementType.ShowSQLDialect:
throw new NotImplementedException();
}
}
catch (Exception ex)
{
await DisposeCommand(async).ConfigureAwait(false);
await RollbackTransaction(async).ConfigureAwait(false);
await CloseConnection(async).ConfigureAwait(false);
throw new FbException(string.Format("An exception was thrown when executing command: {1}.{0}Batch execution aborted.{0}The returned message was: {2}.",
Environment.NewLine,
statement.Text,
ex.Message),
ex);
}
}
await DisposeCommand(async).ConfigureAwait(false);
await CommitTransaction(async).ConfigureAwait(false);
await CloseConnection(async).ConfigureAwait(false);
}
private async Task <DataTable> GetSchemaTableImpl(AsyncWrappingCommonArgs async)
{
CheckState();
if (_schemaTable != null)
{
return(_schemaTable);
}
DataRow schemaRow = null;
var tableCount = 0;
var currentTable = string.Empty;
_schemaTable = GetSchemaTableStructure();
/* Prepare statement for schema fields information */
var schemaCmd = new FbCommand(GetSchemaCommandText(), _command.Connection, _command.Connection.InnerConnection.ActiveTransaction);
try
{
schemaCmd.Parameters.Add("@TABLE_NAME", FbDbType.Char, 31);
schemaCmd.Parameters.Add("@COLUMN_NAME", FbDbType.Char, 31);
await schemaCmd.PrepareImpl(async).ConfigureAwait(false);
_schemaTable.BeginLoadData();
for (var i = 0; i < _fields.Count; i++)
{
var isKeyColumn = false;
var isUnique = false;
var isReadOnly = false;
var precision = 0;
var isExpression = false;
/* Get Schema data for the field */
schemaCmd.Parameters[0].Value = _fields[i].Relation;
schemaCmd.Parameters[1].Value = _fields[i].Name;
var reader = await schemaCmd.ExecuteReaderImpl(CommandBehavior.Default, async).ConfigureAwait(false);
try
{
if (await reader.ReadImpl(async).ConfigureAwait(false))
{
isReadOnly = (IsReadOnly(reader) || IsExpression(reader)) ? true : false;
isKeyColumn = (reader.GetInt32(2) == 1) ? true : false;
isUnique = (reader.GetInt32(3) == 1) ? true : false;
precision = reader.IsDBNull(4) ? -1 : reader.GetInt32(4);
isExpression = IsExpression(reader);
}
}
finally
{
#if NET48 || NETSTANDARD2_0
reader.Dispose();
#else
await async.AsyncSyncCallNoCancellation(reader.DisposeAsync, reader.Dispose).ConfigureAwait(false);
#endif
}
/* Create new row for the Schema Table */
schemaRow = _schemaTable.NewRow();
schemaRow["ColumnName"] = GetName(i);
schemaRow["ColumnOrdinal"] = i;
schemaRow["ColumnSize"] = _fields[i].GetSize();
if (_fields[i].IsDecimal())
{
schemaRow["NumericPrecision"] = schemaRow["ColumnSize"];
if (precision > 0)
{
schemaRow["NumericPrecision"] = precision;
}
schemaRow["NumericScale"] = _fields[i].NumericScale * (-1);
}
schemaRow["DataType"] = GetFieldType(i);
schemaRow["ProviderType"] = GetProviderType(i);
schemaRow["IsLong"] = _fields[i].IsLong();
schemaRow["AllowDBNull"] = _fields[i].AllowDBNull();
schemaRow["IsRowVersion"] = false;
schemaRow["IsAutoIncrement"] = false;
schemaRow["IsReadOnly"] = isReadOnly;
schemaRow["IsKey"] = isKeyColumn;
schemaRow["IsUnique"] = isUnique;
schemaRow["IsAliased"] = _fields[i].IsAliased();
schemaRow["IsExpression"] = isExpression;
schemaRow["BaseSchemaName"] = DBNull.Value;
schemaRow["BaseCatalogName"] = DBNull.Value;
schemaRow["BaseTableName"] = _fields[i].Relation;
schemaRow["BaseColumnName"] = _fields[i].Name;
_schemaTable.Rows.Add(schemaRow);
if (!string.IsNullOrEmpty(_fields[i].Relation) && currentTable != _fields[i].Relation)
{
tableCount++;
currentTable = _fields[i].Relation;
}
await schemaCmd.Close(async).ConfigureAwait(false);
}
if (tableCount > 1)
{
foreach (DataRow row in _schemaTable.Rows)
{
row["IsKey"] = false;
row["IsUnique"] = false;
}
}
_schemaTable.EndLoadData();
}
finally
{
#if NET48 || NETSTANDARD2_0
schemaCmd.Dispose();
#else
await async.AsyncSyncCallNoCancellation(schemaCmd.DisposeAsync, schemaCmd.Dispose).ConfigureAwait(false);
#endif
}
return(_schemaTable);
}