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));
		}
Beispiel #2
0
		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;

			#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);

			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:

			// TODO: Environment.BatchVersionedData
			settings.AdoBatchSize = PropertiesHelper.GetInt32(Environment.BatchSize, properties, 0);
			bool wrapResultSets = PropertiesHelper.GetBoolean(Environment.WrapResultSets, properties, false);
			log.Debug("Wrap result sets: " + EnabledDisabled(wrapResultSets));
			settings.IsWrapResultSetsEnabled = wrapResultSets;
			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);
				}
			}

			EntityMode defaultEntityMode =
				EntityModeHelper.Parse(PropertiesHelper.GetString(Environment.DefaultEntityMode, properties, "poco"));
			log.Info("Default entity-mode: " + defaultEntityMode);
			settings.DefaultEntityMode = defaultEntityMode;

			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

			// 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);
			}

			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 = ParseConnectionReleaseMode(releaseModeName);
			}
			settings.ConnectionReleaseMode = releaseMode;

			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:

			settings.QueryTranslatorFactory = CreateQueryTranslatorFactory(properties);

			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;
			}

			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 (StringHelper.IsEmpty(cacheRegionPrefix)) cacheRegionPrefix = null;
			if (cacheRegionPrefix != null) log.Info("Cache region prefix: " + cacheRegionPrefix);


			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);
				}
			}

			// Not ported - settings.StatementFetchSize = statementFetchSize;
			// Not ported - ScrollableResultSetsEnabled
			// Not ported - GetGeneratedKeysEnabled
			settings.BatchSize = PropertiesHelper.GetInt32(Environment.BatchSize, properties, 0);
			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.MaximumFetchDepth = maxFetchDepth;
			settings.IsQueryCacheEnabled = useQueryCache;
			settings.IsSecondLevelCacheEnabled = useSecondLevelCache;
			settings.CacheRegionPrefix = cacheRegionPrefix;
			settings.IsMinimalPutsEnabled = useMinimalPuts;
			// Not ported - JdbcBatchVersionedData
			// TODO: SQLExceptionConverter
			// TODO: WrapResultSetsEnabled

			// NHibernate-specific:
			settings.IsolationLevel = isolation;

			return settings;
		}