public static FluentConfiguration ExposeDbCommand(this FluentConfiguration fluentConfiguration, Action <IDbCommand, global::NHibernate.Cfg.Configuration> action)
{
fluentConfiguration.ExposeConfiguration(cfg =>
{
DbConnection connection = null;
IConnectionProvider provider = null;
IDbCommand command = null;
try
{
provider = GetConnectionProvider(cfg);
connection = provider.GetConnection();
command = connection.CreateCommand();
command.CommandType = CommandType.Text;
action(command, cfg);
}
finally
{
if (command != null)
{
command.Dispose();
}
if (connection != null)
{
provider.CloseConnection(connection);
provider.Dispose();
}
}
});
return(fluentConfiguration);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_connectionProvider.Dispose();
}
}
private void InitConnectionAndExecute(Action <string> scriptAction, bool execute, bool justDrop, DbConnection connection, TextWriter exportOutput)
{
Initialize();
TextWriter fileOutput = exportOutput;
IConnectionProvider connectionProvider = null;
try
{
if (fileOutput == null && outputFile != null)
{
fileOutput = new StreamWriter(outputFile);
}
if (execute && connection == null)
{
if (_requireTenantConnection)
{
throw new ArgumentException("When Database multi-tenancy is enabled you need to provide explicit connection. Please use overload with connection parameter.");
}
var props = new Dictionary <string, string>();
foreach (var de in dialect.DefaultProperties)
{
props[de.Key] = de.Value;
}
if (configProperties != null)
{
foreach (var de in configProperties)
{
props[de.Key] = de.Value;
}
}
connectionProvider = ConnectionProviderFactory.NewConnectionProvider(props);
connection = connectionProvider.GetConnection();
}
Execute(scriptAction, execute, justDrop, connection, fileOutput);
}
catch (HibernateException)
{
// So that we don't wrap HibernateExceptions in HibernateExceptions
throw;
}
catch (Exception e)
{
log.Error(e, e.Message);
throw new HibernateException(e.Message, e);
}
finally
{
if (connectionProvider != null)
{
connectionProvider.CloseConnection(connection);
connectionProvider.Dispose();
}
}
}
public async Task ExecuteAsync(Action <string> scriptAction, bool execute, bool justDrop, TextWriter exportOutput, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
await(InitializeAsync(cancellationToken)).ConfigureAwait(false);
DbConnection connection = null;
TextWriter fileOutput = exportOutput;
IConnectionProvider connectionProvider = null;
try
{
if (fileOutput == null && outputFile != null)
{
fileOutput = new StreamWriter(outputFile);
}
if (execute)
{
var props = new Dictionary <string, string>();
foreach (var de in dialect.DefaultProperties)
{
props[de.Key] = de.Value;
}
if (configProperties != null)
{
foreach (var de in configProperties)
{
props[de.Key] = de.Value;
}
}
connectionProvider = ConnectionProviderFactory.NewConnectionProvider(props);
connection = await(connectionProvider.GetConnectionAsync(cancellationToken)).ConfigureAwait(false);
}
await(ExecuteAsync(scriptAction, execute, justDrop, connection, fileOutput, cancellationToken)).ConfigureAwait(false);
}
catch (OperationCanceledException) { throw; }
catch (HibernateException)
{
// So that we don't wrap HibernateExceptions in HibernateExceptions
throw;
}
catch (Exception e)
{
log.Error(e, e.Message);
throw new HibernateException(e.Message, e);
}
finally
{
if (connection != null)
{
connectionProvider.CloseConnection(connection);
connectionProvider.Dispose();
}
}
}
public void Execute(Action <string> scriptAction, bool export, bool justDrop)
{
Initialize();
IDbConnection connection = null;
StreamWriter fileOutput = null;
IConnectionProvider connectionProvider = null;
var props = new Dictionary <string, string>();
foreach (var de in dialect.DefaultProperties)
{
props[de.Key] = de.Value;
}
if (configProperties != null)
{
foreach (var de in configProperties)
{
props[de.Key] = de.Value;
}
}
try
{
if (outputFile != null)
{
fileOutput = new StreamWriter(outputFile);
}
if (export)
{
connectionProvider = ConnectionProviderFactory.NewConnectionProvider(props);
connection = connectionProvider.GetConnection();
}
Execute(scriptAction, export, justDrop, connection, fileOutput);
}
catch (HibernateException)
{
// So that we don't wrap HibernateExceptions in HibernateExceptions
throw;
}
catch (Exception e)
{
log.Error(e.Message, e);
throw new HibernateException(e.Message, e);
}
finally
{
if (connection != null)
{
connectionProvider.CloseConnection(connection);
connectionProvider.Dispose();
}
}
}
protected virtual void Dispose(bool isDisposing)
{
if (!isDisposing)
{
return;
}
_disposeCalled = true;
// We cannot set connection pool to be null,
// otherwise we might get NPE when using concurrently with NewSession
_connectionProvider.Dispose();
_logger = null;
}
private void dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
if (_connectionProvider != null)
{
_connectionProvider.Dispose();
_connectionProvider = null;
}
}
_disposed = true;
}
}
public void Dispose()
{
_connectionProvider.Dispose();
}
/// <summary>
/// Executes the Export of the Schema.
/// </summary>
/// <param name="script"><c>true</c> if the ddl should be outputted in the Console.</param>
/// <param name="export"><c>true</c> if the ddl should be executed against the Database.</param>
/// <param name="justDrop"><c>true</c> if only the ddl to drop the Database objects should be executed.</param>
/// <param name="format"><c>true</c> if the ddl should be nicely formatted instead of one statement per line.</param>
/// <remarks>
/// This method allows for both the drop and create ddl script to be executed.
/// </remarks>
public void Execute(bool script, bool export, bool justDrop, bool format)
{
IDbConnection connection = null;
StreamWriter fileOutput = null;
IConnectionProvider connectionProvider = null;
IDbCommand statement = null;
IDictionary props = new Hashtable();
foreach (DictionaryEntry de in dialect.DefaultProperties)
{
props[de.Key] = de.Value;
}
if (connectionProperties != null)
{
foreach (DictionaryEntry de in connectionProperties)
{
props[de.Key] = de.Value;
}
}
try
{
if (outputFile != null)
{
fileOutput = new StreamWriter(outputFile);
}
if (export)
{
connectionProvider = ConnectionProviderFactory.NewConnectionProvider(props);
connection = connectionProvider.GetConnection();
statement = connection.CreateCommand();
}
for (int i = 0; i < dropSQL.Length; i++)
{
try
{
string formatted;
if (format)
{
formatted = Format(dropSQL[i]);
}
else
{
formatted = dropSQL[i];
}
if (delimiter != null)
{
formatted += delimiter;
}
if (script)
{
Console.WriteLine(formatted);
}
if (outputFile != null)
{
fileOutput.WriteLine(formatted);
}
if (export)
{
statement.CommandText = dropSQL[i];
statement.CommandType = CommandType.Text;
statement.ExecuteNonQuery();
}
}
catch (Exception e)
{
if (!script)
{
Console.WriteLine(dropSQL[i]);
}
Console.WriteLine("Unsuccessful: " + e.Message);
}
}
if (!justDrop)
{
for (int j = 0; j < createSQL.Length; j++)
{
try
{
string formatted;
if (format)
{
formatted = Format(createSQL[j]);
}
else
{
formatted = createSQL[j];
}
if (delimiter != null)
{
formatted += delimiter;
}
if (script)
{
Console.WriteLine(formatted);
}
if (outputFile != null)
{
fileOutput.WriteLine(formatted);
}
if (export)
{
statement.CommandText = createSQL[j];
statement.CommandType = CommandType.Text;
statement.ExecuteNonQuery();
}
}
catch (Exception e)
{
if (!script)
{
Console.WriteLine(createSQL[j]);
}
Console.WriteLine("Unsuccessful: " + e.Message);
// Fail on create script errors
throw;
}
}
}
}
catch (HibernateException)
{
// So that we don't wrap HibernateExceptions in HibernateExceptions
throw;
}
catch (Exception e)
{
Console.Write(e.StackTrace);
throw new HibernateException(e.Message, e);
}
finally
{
try
{
if (statement != null)
{
statement.Dispose();
}
if (connection != null)
{
connectionProvider.CloseConnection(connection);
connectionProvider.Dispose();
}
}
catch (Exception e)
{
Console.Error.WriteLine("Could not close connection: " + e.Message);
}
if (fileOutput != null)
{
try
{
fileOutput.Close();
}
catch (Exception ioe)
{
Console.Error.WriteLine("Error closing output file " + outputFile + ": " + ioe.Message);
}
}
}
}
public void Dispose()
{
_base.Dispose();
}
