public override void Process(PerformDBOperationExpression expression)
{
//RegisterExpression<PerformDBOperationExpression>(expression);
Announcer.Say("Performing DB Operation");
if (Options.PreviewOnly)
{
return;
}
if (Connection.State != ConnectionState.Open)
{
Connection.Open();
}
if (expression.Operation != null)
{
expression.Operation(Connection, Transaction);
if (FBOptions.TransactionModel == FirebirdTransactionModel.AutoCommit)
{
CommitRetaining();
}
}
}
public override void RollbackTransaction()
{
base.RollbackTransaction();
if (FBOptions.UndoEnabled && processedExpressions != null && processedExpressions.Count > 0)
{
processedExpressions.Pop(); //the last transaction is already rolled back
if (processedExpressions.Count > 0)
{
Announcer.Say("Undoing {0} transaction(s)", processedExpressions.Count);
}
while (processedExpressions.Count > 0)
{
Announcer.Say("Undoing transaction {0}", processedExpressions.Count);
Stack <FirebirdProcessedExpressionBase> expressions = processedExpressions.Pop();
while (expressions.Count > 0)
{
expressions.Pop().Undo(Connection);
}
}
}
EnsureConnectionIsClosed();
ClearLocks();
}
public override void RollbackTransaction()
{
Announcer.Say("Rolling back transaction");
Transaction.Rollback();
WasCommitted = true;
if (FBOptions.UndoEnabled)
{
processedExpressions.Pop(); //the last transaction is already rolled back
if (processedExpressions.Count > 0)
{
Announcer.Say("Undoing {0} transaction(s)", processedExpressions.Count);
}
while (processedExpressions.Count > 0)
{
Announcer.Say("Undoing transaction {0}", processedExpressions.Count);
Stack <FirebirdProcessedExpressionBase> expressions = processedExpressions.Pop();
while (expressions.Count > 0)
{
expressions.Pop().Undo(Connection);
}
}
}
if (Connection.State != ConnectionState.Closed)
{
Connection.Close();
}
ClearLocks();
}
public override void BeginTransaction()
{
Announcer.Say("Beginning Transaction");
Transaction = Connection.BeginTransaction();
ClearLocks();
ClearExpressions();
ClearDDLFollowers();
}
public override void RollbackTransaction()
{
Announcer.Say("Rolling back transaction");
Transaction.Rollback();
if (Connection.State != ConnectionState.Closed)
{
Connection.Close();
}
}
public override void CommitTransaction()
{
Announcer.Say("Committing Transaction");
Transaction.Commit();
if (Connection.State != ConnectionState.Closed)
{
Connection.Close();
}
}
public override void BeginTransaction()
{
Announcer.Say("Beginning Transaction");
if (Connection.State == ConnectionState.Closed)
{
Connection.Open();
}
Transaction = Connection.BeginTransaction();
}
public void Say_Should_Write()
{
var message = "TheMessage";
Mock.Get(announcer).Setup(a => a.Write(message, true)).Verifiable();
announcer.Say(message);
Mock.Get(announcer).VerifyAll();
}
public PostgresProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
: base(generator, announcer, options)
{
this.factory = factory;
Connection = connection;
connection.Open();
Announcer.Say("Beginning Transaction");
Transaction = Connection.BeginTransaction();
}
public override void CommitTransaction()
{
Announcer.Say("Committing Transaction");
Transaction.Commit();
WasCommitted = true;
if (Connection.State != ConnectionState.Closed)
{
Connection.Close();
}
ClearLocks();
}
public virtual void CommitRetaining()
{
Announcer.Say("Committing and Retaining Transaction");
using (var command = Factory.CreateCommand("COMMIT RETAIN", Connection, Transaction))
{
command.CommandTimeout = Options.Timeout;
command.ExecuteNonQuery();
}
processedExpressions.Push(new Stack <FirebirdProcessedExpressionBase>());
}
public override void BeginTransaction()
{
if (Transaction != null)
{
return;
}
EnsureConnectionIsOpen();
Announcer.Say("Beginning Transaction");
Transaction = Connection.BeginTransaction();
}
public override void RollbackTransaction()
{
if (Transaction == null)
{
return;
}
Announcer.Say("Rolling back transaction");
Transaction.Rollback();
WasCommitted = true;
Transaction = null;
}
public override void CommitTransaction()
{
if (Transaction == null)
{
return;
}
Announcer.Say("Committing Transaction");
Transaction.Commit();
WasCommitted = true;
Transaction = null;
}
protected override void EnsureConnectionIsClosed()
{
if (Connection.State != ConnectionState.Closed)
{
if (Connection.State == ConnectionState.Open && Options.ProviderSwitches.Contains("SingleUserMode") && isInSingleUserMode)
{
Announcer.Say("Exiting Single User Mode");
Process("declare @sql varchar(100);set @sql='alter database '+quotename(db_name())+' SET MULTI_USER'; exec(@sql)");
isInSingleUserMode = false;
}
Connection.Close();
}
}
public virtual void CommitRetaining()
{
if (IsRunningOutOfMigrationScope())
{
EnsureConnectionIsClosed();
return;
}
Announcer.Say("Committing and Retaining Transaction");
CommitTransaction();
BeginTransaction();
}
protected override void EnsureConnectionIsOpen()
{
if (Connection.State != ConnectionState.Open)
{
Connection.Open();
if (Options.ProviderSwitches.Contains("SingleUserMode") && !isInSingleUserMode)
{
Announcer.Say("Entering Single User Mode");
Process("declare @sql varchar(100);set @sql='alter database '+quotename(db_name())+' SET SINGLE_USER WITH ROLLBACK IMMEDIATE'; exec(@sql)");
isInSingleUserMode = true;
}
}
}
public override void Process(PerformDBOperationExpression expression)
{
Announcer.Say("Performing DB Operation");
if (Options.PreviewOnly)
{
return;
}
EnsureConnectionIsOpen();
expression.Operation?.Invoke(Connection, Transaction);
}
public override void CommitTransaction()
{
Announcer.Say("Committing Transaction");
if (transaction != null)
{
transaction.Commit();
transaction = null;
}
if (connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
public override void Process(PerformDBOperationExpression expression)
{
Announcer.Say("Performing DB Operation");
if (Options.PreviewOnly)
{
return;
}
EnsureConnectionIsOpen();
if (expression.Operation != null)
{
expression.Operation(Connection, null);
}
}
public override void CommitTransaction()
{
Announcer.Say("Committing Transaction");
if (Transaction != null)
{
Transaction.Commit();
Transaction = null;
}
WasCommitted = true;
if (Connection.State != ConnectionState.Closed)
{
Connection.Close();
}
}
public override void RollbackTransaction()
{
if (transaction == null)
{
Announcer.Say("No transaction was available to rollback!");
return;
}
Announcer.Say("Rolling back transaction");
transaction.Rollback();
if (connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
public override void Process(CreateSchemaExpression expression)
{
var password = expression.GetAdditionalFeature(SqlAnywhereExtensions.SchemaPassword, string.Empty);
if (string.IsNullOrEmpty(password))
{
throw new Exception("Create schema requires connection for the schema user. No password specified in CreateSchemaExpression.");
}
if (!Exists("SELECT count(*) FROM \"dbo\".\"syslogins\" WHERE \"name\"='{0}'", FormatHelper.FormatSqlEscape(expression.SchemaName)))
{
// Try to automatically generate the user
Announcer.Say("Creating user {0}.", expression.SchemaName);
Execute("CREATE USER \"{0}\" IDENTIFIED BY \"{1}\"", expression.SchemaName, password);
}
var sql = Generator.Generate(expression);
string connectionString = ReplaceUserIdAndPasswordInConnectionString(expression.SchemaName, password);
Announcer.Say("Creating connection for user {0} to create schema.", expression.SchemaName);
var connection = Factory.CreateConnection(connectionString);
EnsureConnectionIsOpen(connection);
Announcer.Say("Beginning out of scope transaction to create schema.");
var transaction = connection.BeginTransaction();
try
{
ExecuteNonQuery(connection, transaction, sql);
transaction.Commit();
Announcer.Say("Out of scope transaction to create schema committed.");
}
catch
{
transaction.Rollback();
Announcer.Say("Out of scope transaction to create schema rolled back.");
throw;
}
finally
{
transaction?.Dispose();
connection.Dispose();
}
}
public virtual void CommitRetaining()
{
if (IsRunningOutOfMigrationScope())
{
return;
}
Announcer.Say("Committing and Retaining Transaction");
CommitTransaction();
BeginTransaction();
/*using (var command = Factory.CreateCommand("COMMIT RETAIN", Connection, Transaction))
* {
* command.CommandTimeout = Options.Timeout;
* command.ExecuteNonQuery();
* }*/
processedExpressions.Push(new Stack <FirebirdProcessedExpressionBase>());
}
public override void Process(PerformDBOperationExpression expression)
{
Announcer.Say("Performing DB Operation");
if (Options.PreviewOnly)
{
return;
}
if (Connection.State != ConnectionState.Open)
{
Connection.Open();
}
if (expression.Operation != null)
{
expression.Operation(Connection, Transaction);
}
}
public override void Process(PerformDBOperationExpression expression)
{
Announcer.Say("Performing DB Operation");
if (Options.PreviewOnly)
{
return;
}
EnsureConnectionIsOpen();
if (expression.Operation != null)
{
expression.Operation(Connection, Transaction);
if (FBOptions.TransactionModel == FirebirdTransactionModel.AutoCommit)
{
CommitRetaining();
}
}
}
public void Process(PerformDBOperationExpression expression)
{
Announcer.Say("Performing DB Operation");
}
public void Process(Builders.Execute.PerformDBOperationExpression expression)
{
Announcer.Say("Performing DB Operation");
}
public void AnnounceUsing(Announcer announcer)
{
announcer.Say(ToString());
}
public override void BeginTransaction()
{
Announcer.Say("Beginning Transaction");
Transaction = Connection.BeginTransaction();
}