public override void RunCommand()
{
IDatabaseSource srcDb = m_source.GetConnection();
IDatabaseSource dstDb = m_target.GetConnection();
Async.SafeOpen(srcDb.Connection); Async.SafeOpen(dstDb.Connection);
var src = srcDb.InvokeLoadStructure(DatabaseStructureMembers.FullStructure, null);
var dst = dstDb.InvokeLoadStructure(DatabaseStructureMembers.FullStructure, null);
var opts = new DbDiffOptions();
opts.IgnoreColumnOrder = true;
//var diff = new DatabaseDiff(src, dst, opts);
ISqlDialect dial;
if (Dialect != null)
{
dial = (ISqlDialect)DialectAddonType.Instance.FindHolder(Dialect).CreateInstance();
}
else
{
dial = new GenericDialect();
}
using (TextWriter fw = GetOutputStream())
{
SqlOutputStream so = new SqlOutputStream(dial, fw, new SqlFormatProperties());
ISqlDumper dmp = dial.CreateDumper(so, new SqlFormatProperties());
dmp.AlterDatabase(src, dst, opts, new DbDefSource(src, DbDefSource.ReadOnly.Flag));
//dmp.TargetDb = new DbDefSource(dst, DbDefSource.ReadOnly.Flag);
//diff.Actions.GenerateScript(dmp);
}
Async.SafeClose(srcDb.Connection); Async.SafeClose(dstDb.Connection);
}
protected override void AfterCreateConnection(IPhysicalConnection conn)
{
GenericDialect dialect = ((GenericDbConnection)conn).Dialect as GenericDialect;
//if (dialect != null) dialect.Connection = conn.SystemConnection;
if (DatabaseMode == ConnectionDatabaseMode.Explicit)
{
conn.SystemConnection.SafeChangeDatabase(ExplicitDatabaseName);
}
}
private static string AdjustColumnNameToMaxLength(string columnName, GenericDialect dialect, int referenceMaxLength)
{
if (dialect.MaxAliasLength > referenceMaxLength)
{
columnName = new string('w', dialect.MaxAliasLength - referenceMaxLength) + columnName;
}
else if (dialect.MaxAliasLength < referenceMaxLength)
{
Assert.Fail("Dialect max alias length is too short for the test.");
}
return(columnName);
}
public void GetAliasRespectsMaxAliasLength(string columnName)
{
var dialect = new GenericDialect();
// Test case is meant for a max length of 10, adjusts name if it is more.
columnName = AdjustColumnNameToMaxLength(columnName, dialect, 10);
var column = new Column(columnName);
string generatedAlias = column.GetAlias(dialect);
Assert.That(generatedAlias, Has.Length.LessThanOrEqualTo(dialect.MaxAliasLength - _charactersLeftCount));
}
public void GetAliasRespectsMaxAliasLength(string columnName)
{
var dialect = new GenericDialect();
// Verify test case assumption.
Assert.That(dialect.MaxAliasLength, Is.EqualTo(10));
var column = new Column(columnName);
string generatedAlias = column.GetAlias(dialect);
Assert.That(generatedAlias, Has.Length.LessThanOrEqualTo(dialect.MaxAliasLength));
}
public void LimitBehaviorTypesRender(LimitBehavior limitBehavior, OffsetBehavior offsetBehavior, string expectedResult)
{
var dialect = new GenericDialect {
LimitBehavior = limitBehavior, OffsetBehavior = offsetBehavior
};
var context = new RenderContext(dialect);
var sut = new Select
{
Columns = "Column",
From = "Table",
Limit = 5
} as ISqlElement;
sut.Render(context);
Assert.Equal(expectedResult, context.CommandText);
}
public Settings BuildSettings(IDictionary <string, string> properties)
{
Settings settings = new Settings();
Dialect.Dialect dialect;
try
{
dialect = Dialect.Dialect.GetDialect(properties);
Dictionary <string, string> temp = new Dictionary <string, string>();
foreach (KeyValuePair <string, string> de in dialect.DefaultProperties)
{
temp[de.Key] = de.Value;
}
foreach (KeyValuePair <string, string> de in properties)
{
temp[de.Key] = de.Value;
}
properties = temp;
}
catch (HibernateException he)
{
log.Warn("No dialect set - using GenericDialect: " + he.Message);
dialect = new GenericDialect();
}
settings.Dialect = dialect;
settings.LinqToHqlGeneratorsRegistry = LinqToHqlGeneratorsRegistryFactory.CreateGeneratorsRegistry(properties);
#region SQL Exception converter
ISQLExceptionConverter sqlExceptionConverter;
try
{
sqlExceptionConverter = SQLExceptionConverterFactory.BuildSQLExceptionConverter(dialect, properties);
}
catch (HibernateException)
{
log.Warn("Error building SQLExceptionConverter; using minimal converter");
sqlExceptionConverter = SQLExceptionConverterFactory.BuildMinimalSQLExceptionConverter();
}
settings.SqlExceptionConverter = sqlExceptionConverter;
#endregion
bool comments = PropertiesHelper.GetBoolean(Environment.UseSqlComments, properties);
log.Info("Generate SQL with comments: " + EnabledDisabled(comments));
settings.IsCommentsEnabled = comments;
int maxFetchDepth = PropertiesHelper.GetInt32(Environment.MaxFetchDepth, properties, -1);
if (maxFetchDepth != -1)
{
log.Info("Maximum outer join fetch depth: " + maxFetchDepth);
}
IConnectionProvider connectionProvider = ConnectionProviderFactory.NewConnectionProvider(properties);
ITransactionFactory transactionFactory = CreateTransactionFactory(properties);
// TransactionManagerLookup transactionManagerLookup = TransactionManagerLookupFactory.GetTransactionManagerLookup( properties );
// Not ported: useGetGeneratedKeys, useScrollableResultSets
bool useMinimalPuts = PropertiesHelper.GetBoolean(Environment.UseMinimalPuts, properties, false);
log.Info("Optimize cache for minimal puts: " + useMinimalPuts);
string releaseModeName = PropertiesHelper.GetString(Environment.ReleaseConnections, properties, "auto");
log.Info("Connection release mode: " + releaseModeName);
ConnectionReleaseMode releaseMode;
if ("auto".Equals(releaseModeName))
{
releaseMode = ConnectionReleaseMode.AfterTransaction; //transactionFactory.DefaultReleaseMode;
}
else
{
releaseMode = ConnectionReleaseModeParser.Convert(releaseModeName);
}
settings.ConnectionReleaseMode = releaseMode;
string defaultSchema = PropertiesHelper.GetString(Environment.DefaultSchema, properties, null);
string defaultCatalog = PropertiesHelper.GetString(Environment.DefaultCatalog, properties, null);
if (defaultSchema != null)
{
log.Info("Default schema: " + defaultSchema);
}
if (defaultCatalog != null)
{
log.Info("Default catalog: " + defaultCatalog);
}
settings.DefaultSchemaName = defaultSchema;
settings.DefaultCatalogName = defaultCatalog;
int batchFetchSize = PropertiesHelper.GetInt32(Environment.DefaultBatchFetchSize, properties, 1);
log.Info("Default batch fetch size: " + batchFetchSize);
settings.DefaultBatchFetchSize = batchFetchSize;
//Statistics and logging:
bool showSql = PropertiesHelper.GetBoolean(Environment.ShowSql, properties, false);
if (showSql)
{
log.Info("echoing all SQL to stdout");
}
bool formatSql = PropertiesHelper.GetBoolean(Environment.FormatSql, properties);
bool useStatistics = PropertiesHelper.GetBoolean(Environment.GenerateStatistics, properties);
log.Info("Statistics: " + EnabledDisabled(useStatistics));
settings.IsStatisticsEnabled = useStatistics;
bool useIdentifierRollback = PropertiesHelper.GetBoolean(Environment.UseIdentifierRollBack, properties);
log.Info("Deleted entity synthetic identifier rollback: " + EnabledDisabled(useIdentifierRollback));
settings.IsIdentifierRollbackEnabled = useIdentifierRollback;
// queries:
settings.QueryTranslatorFactory = CreateQueryTranslatorFactory(properties);
settings.LinqQueryProviderType = CreateLinqQueryProviderType(properties);
IDictionary <string, string> querySubstitutions = PropertiesHelper.ToDictionary(Environment.QuerySubstitutions,
" ,=;:\n\t\r\f", properties);
if (log.IsInfoEnabled)
{
log.Info("Query language substitutions: " + CollectionPrinter.ToString((IDictionary)querySubstitutions));
}
#region Hbm2DDL
string autoSchemaExport = PropertiesHelper.GetString(Environment.Hbm2ddlAuto, properties, null);
if (SchemaAutoAction.Update == autoSchemaExport)
{
settings.IsAutoUpdateSchema = true;
}
else if (SchemaAutoAction.Create == autoSchemaExport)
{
settings.IsAutoCreateSchema = true;
}
else if (SchemaAutoAction.Recreate == autoSchemaExport)
{
settings.IsAutoCreateSchema = true;
settings.IsAutoDropSchema = true;
}
else if (SchemaAutoAction.Validate == autoSchemaExport)
{
settings.IsAutoValidateSchema = true;
}
string autoKeyWordsImport = PropertiesHelper.GetString(Environment.Hbm2ddlKeyWords, properties, "not-defined");
autoKeyWordsImport = autoKeyWordsImport.ToLowerInvariant();
if (autoKeyWordsImport == Hbm2DDLKeyWords.None)
{
settings.IsKeywordsImportEnabled = false;
settings.IsAutoQuoteEnabled = false;
}
else if (autoKeyWordsImport == Hbm2DDLKeyWords.Keywords)
{
settings.IsKeywordsImportEnabled = true;
}
else if (autoKeyWordsImport == Hbm2DDLKeyWords.AutoQuote)
{
settings.IsKeywordsImportEnabled = true;
settings.IsAutoQuoteEnabled = true;
}
else if (autoKeyWordsImport == "not-defined")
{
settings.IsKeywordsImportEnabled = true;
settings.IsAutoQuoteEnabled = false;
}
#endregion
bool useSecondLevelCache = PropertiesHelper.GetBoolean(Environment.UseSecondLevelCache, properties, true);
bool useQueryCache = PropertiesHelper.GetBoolean(Environment.UseQueryCache, properties);
if (useSecondLevelCache || useQueryCache)
{
// The cache provider is needed when we either have second-level cache enabled
// or query cache enabled. Note that useSecondLevelCache is enabled by default
settings.CacheProvider = CreateCacheProvider(properties);
}
else
{
settings.CacheProvider = new NoCacheProvider();
}
string cacheRegionPrefix = PropertiesHelper.GetString(Environment.CacheRegionPrefix, properties, null);
if (string.IsNullOrEmpty(cacheRegionPrefix))
{
cacheRegionPrefix = null;
}
if (cacheRegionPrefix != null)
{
log.Info("Cache region prefix: " + cacheRegionPrefix);
}
if (useQueryCache)
{
string queryCacheFactoryClassName = PropertiesHelper.GetString(Environment.QueryCacheFactory, properties,
typeof(StandardQueryCacheFactory).FullName);
log.Info("query cache factory: " + queryCacheFactoryClassName);
try
{
settings.QueryCacheFactory =
(IQueryCacheFactory)
Environment.BytecodeProvider.ObjectsFactory.CreateInstance(ReflectHelper.ClassForName(queryCacheFactoryClassName));
}
catch (Exception cnfe)
{
throw new HibernateException("could not instantiate IQueryCacheFactory: " + queryCacheFactoryClassName, cnfe);
}
}
string sessionFactoryName = PropertiesHelper.GetString(Environment.SessionFactoryName, properties, null);
//ADO.NET and connection settings:
settings.AdoBatchSize = PropertiesHelper.GetInt32(Environment.BatchSize, properties, 0);
bool orderInserts = PropertiesHelper.GetBoolean(Environment.OrderInserts, properties, (settings.AdoBatchSize > 0));
log.Info("Order SQL inserts for batching: " + EnabledDisabled(orderInserts));
settings.IsOrderInsertsEnabled = orderInserts;
bool orderUpdates = PropertiesHelper.GetBoolean(Environment.OrderUpdates, properties, false);
log.Info("Order SQL updates for batching: " + EnabledDisabled(orderUpdates));
settings.IsOrderUpdatesEnabled = orderUpdates;
bool wrapResultSets = PropertiesHelper.GetBoolean(Environment.WrapResultSets, properties, false);
log.Debug("Wrap result sets: " + EnabledDisabled(wrapResultSets));
settings.IsWrapResultSetsEnabled = wrapResultSets;
bool batchVersionedData = PropertiesHelper.GetBoolean(Environment.BatchVersionedData, properties, false);
log.Debug("Batch versioned data: " + EnabledDisabled(batchVersionedData));
settings.IsBatchVersionedDataEnabled = batchVersionedData;
settings.BatcherFactory = CreateBatcherFactory(properties, settings.AdoBatchSize, connectionProvider);
string isolationString = PropertiesHelper.GetString(Environment.Isolation, properties, String.Empty);
IsolationLevel isolation = IsolationLevel.Unspecified;
if (isolationString.Length > 0)
{
try
{
isolation = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), isolationString);
log.Info("Using Isolation Level: " + isolation);
}
catch (ArgumentException ae)
{
log.Error("error configuring IsolationLevel " + isolationString, ae);
throw new HibernateException(
"The isolation level of " + isolationString + " is not a valid IsolationLevel. Please "
+ "use one of the Member Names from the IsolationLevel.", ae);
}
}
//NH-3619
FlushMode defaultFlushMode = (FlushMode)Enum.Parse(typeof(FlushMode), PropertiesHelper.GetString(Environment.DefaultFlushMode, properties, FlushMode.Auto.ToString()), false);
log.Info("Default flush mode: " + defaultFlushMode);
settings.DefaultFlushMode = defaultFlushMode;
#pragma warning disable CS0618 // Type or member is obsolete
var defaultEntityMode = PropertiesHelper.GetString(Environment.DefaultEntityMode, properties, null);
if (!string.IsNullOrEmpty(defaultEntityMode))
{
log.Warn("Default entity-mode setting is deprecated.");
}
#pragma warning restore CS0618 // Type or member is obsolete
bool namedQueryChecking = PropertiesHelper.GetBoolean(Environment.QueryStartupChecking, properties, true);
log.Info("Named query checking : " + EnabledDisabled(namedQueryChecking));
settings.IsNamedQueryStartupCheckingEnabled = namedQueryChecking;
// Not ported - settings.StatementFetchSize = statementFetchSize;
// Not ported - ScrollableResultSetsEnabled
// Not ported - GetGeneratedKeysEnabled
settings.SqlStatementLogger = new SqlStatementLogger(showSql, formatSql);
settings.ConnectionProvider = connectionProvider;
settings.QuerySubstitutions = querySubstitutions;
settings.TransactionFactory = transactionFactory;
// Not ported - TransactionManagerLookup
settings.SessionFactoryName = sessionFactoryName;
settings.MaximumFetchDepth = maxFetchDepth;
settings.IsQueryCacheEnabled = useQueryCache;
settings.IsSecondLevelCacheEnabled = useSecondLevelCache;
settings.CacheRegionPrefix = cacheRegionPrefix;
settings.IsMinimalPutsEnabled = useMinimalPuts;
// Not ported - JdbcBatchVersionedData
settings.QueryModelRewriterFactory = CreateQueryModelRewriterFactory(properties);
// NHibernate-specific:
settings.IsolationLevel = isolation;
return(settings);
}
public static Settings BuildSettings(IDictionary properties)
{
Settings settings = new Settings();
Dialect.Dialect dialect = null;
try
{
dialect = Dialect.Dialect.GetDialect(properties);
IDictionary temp = new Hashtable();
foreach (DictionaryEntry de in dialect.DefaultProperties)
{
temp[de.Key] = de.Value;
}
foreach (DictionaryEntry de in properties)
{
temp[de.Key] = de.Value;
}
properties = temp;
}
catch (HibernateException he)
{
log.Warn("No dialect set - using GenericDialect: " + he.Message);
dialect = new GenericDialect();
}
// TODO: SQLExceptionConverter
// TODO: should this be enabled?
// int statementFetchSize = PropertiesHelper.GetInt32( Environment.StatementFetchSize, properties, -1 );
// if( statementFetchSize != -1 )
// {
// log.Info( "JDBC result set fetch size: " + statementFetchSize );
// }
int maxFetchDepth = PropertiesHelper.GetInt32(Environment.MaxFetchDepth, properties, -1);
if (maxFetchDepth != -1)
{
log.Info("Maximum outer join fetch depth: " + maxFetchDepth);
}
//deprecated:
bool useOuterJoin = PropertiesHelper.GetBoolean(Environment.UseOuterJoin, properties, true);
log.Info("use outer join fetching: " + useOuterJoin);
IConnectionProvider connectionProvider = ConnectionProviderFactory.NewConnectionProvider(properties);
ITransactionFactory transactionFactory = new TransactionFactory(); // = TransactionFactoryFactory.BuildTransactionFactory(properties);
// TransactionManagerLookup transactionManagerLookup = TransactionManagerLookupFactory.GetTransactionManagerLookup( properties );
// Not ported: useGetGeneratedKeys, useScrollableResultSets
bool useMinimalPuts = PropertiesHelper.GetBoolean(Environment.UseMinimalPuts, properties, false);
log.Info("Optimize cache for minimal puts: " + useMinimalPuts);
string defaultSchema = properties[Environment.DefaultSchema] as string;
if (defaultSchema != null)
{
log.Info("Default schema set to: " + defaultSchema);
}
bool showSql = PropertiesHelper.GetBoolean(Environment.ShowSql, properties, false);
if (showSql)
{
log.Info("echoing all SQL to stdout");
}
// queries:
IDictionary querySubstitutions = PropertiesHelper.ToDictionary(Environment.QuerySubstitutions, " ,=;:\n\t\r\f", properties);
if (log.IsInfoEnabled)
{
log.Info("Query language substitutions: " + CollectionPrinter.ToString(querySubstitutions));
}
string autoSchemaExport = properties[Environment.Hbm2ddlAuto] as string;
if ("update" == autoSchemaExport)
{
settings.IsAutoUpdateSchema = true;
}
if ("create" == autoSchemaExport)
{
settings.IsAutoCreateSchema = true;
}
if ("create-drop" == autoSchemaExport)
{
settings.IsAutoCreateSchema = true;
settings.IsAutoDropSchema = true;
}
string cacheClassName = PropertiesHelper.GetString(Environment.CacheProvider, properties, "NHibernate.Cache.HashtableCacheProvider");
log.Info("cache provider: " + cacheClassName);
try
{
settings.CacheProvider = ( ICacheProvider )Activator.CreateInstance(ReflectHelper.ClassForName(cacheClassName));
}
catch (Exception e)
{
throw new HibernateException("could not instantiate CacheProvider: " + cacheClassName, e);
}
bool useQueryCache = PropertiesHelper.GetBoolean(Environment.UseQueryCache, properties);
if (useQueryCache)
{
string queryCacheFactoryClassName = PropertiesHelper.GetString(Environment.QueryCacheFactory, properties, "NHibernate.Cache.StandardQueryCacheFactory");
log.Info("query cache factory: " + queryCacheFactoryClassName);
try
{
settings.QueryCacheFactory = (IQueryCacheFactory)Activator.CreateInstance(
ReflectHelper.ClassForName(queryCacheFactoryClassName));
}
catch (Exception cnfe)
{
throw new HibernateException("could not instantiate IQueryCacheFactory: " + queryCacheFactoryClassName, cnfe);
}
}
string sessionFactoryName = ( string )properties[Environment.SessionFactoryName];
// TODO: Environment.BatchVersionedData
// TODO: wrapResultSets/DataReaders
string isolationString = PropertiesHelper.GetString(Environment.Isolation, properties, String.Empty);
IsolationLevel isolation = IsolationLevel.Unspecified;
if (isolationString.Length > 0)
{
try
{
isolation = ( IsolationLevel )Enum.Parse(typeof(IsolationLevel), isolationString);
log.Info("Using Isolation Level: " + isolation.ToString());
}
catch (ArgumentException ae)
{
log.Error("error configuring IsolationLevel " + isolationString, ae);
throw new HibernateException(
"The isolation level of " + isolationString + " is not a valid IsolationLevel. Please " +
"use one of the Member Names from the IsolationLevel.", ae);
}
}
bool prepareSql = PropertiesHelper.GetBoolean(Environment.PrepareSql, properties, false);
int cmdTimeout = PropertiesHelper.GetInt32(Environment.CommandTimeout, properties, 0);
// Not ported - settings.StatementFetchSize = statementFetchSize;
// Not ported - ScrollableResultSetsEnabled
// Not ported - GetGeneratedKeysEnabled
// Not ported - settings.BatchSize = batchSize;
settings.DefaultSchemaName = defaultSchema;
settings.IsShowSqlEnabled = showSql;
settings.Dialect = dialect;
settings.ConnectionProvider = connectionProvider;
settings.QuerySubstitutions = querySubstitutions;
settings.TransactionFactory = transactionFactory;
// Not ported - TransactionManagerLookup
settings.SessionFactoryName = sessionFactoryName;
settings.IsOuterJoinFetchEnabled = useOuterJoin;
settings.MaximumFetchDepth = maxFetchDepth;
settings.IsQueryCacheEnabled = useQueryCache;
settings.IsMinimalPutsEnabled = useMinimalPuts;
// Not ported - JdbcBatchVersionedData
// TODO: SQLExceptionConverter
// TODO: WrapResultSetsEnabled
// NHibernate-specific:
settings.IsolationLevel = isolation;
settings.PrepareSql = prepareSql;
settings.CommandTimeout = cmdTimeout;
return(settings);
}