public UpdateTimestampsCache(Settings settings, IDictionary props) { string prefix = settings.CacheRegionPrefix; regionName = prefix == null ? regionName : prefix + '.' + regionName; log.Info("starting update timestamps cache at region: " + regionName); this.updateTimestamps = settings.CacheProvider.BuildCache(regionName, props); }
public IQueryCache GetQueryCache(string regionName, UpdateTimestampsCache updateTimestampsCache, Settings settings, IDictionary<string, string> props) { return new ProjectionEnabledQueryCache(settings, props, updateTimestampsCache, regionName); }
public IQueryCache GetQueryCache(string regionName, UpdateTimestampsCache updateTimestampsCache, Settings settings, IDictionary props) { return new StandardQueryCache(settings, props, updateTimestampsCache, regionName); }
public SchemaUpdate(Configuration cfg, Settings settings) { configuration = cfg; dialect = settings.Dialect; connectionHelper = new SuppliedConnectionProviderConnectionHelper(settings.ConnectionProvider); exceptions = new List<Exception>(); formatter = (settings.SqlStatementLogger.FormatSql ? FormatStyle.Ddl : FormatStyle.None).Formatter; }
public SchemaUpdate(Configuration cfg, Settings settings) { configuration = cfg; dialect = settings.Dialect; connectionHelper = new SuppliedConnectionProviderConnectionHelper( settings.ConnectionProvider ); exceptions = new ArrayList(); }
public TolerantQueryCache(Settings settings, IDictionary<string, string> props, UpdateTimestampsCache updateTimestampsCache, string regionName) : base(settings, props, updateTimestampsCache, regionName) { isAlwaysTolerant = props.IsQueryCacheRegionAlwaysTolerant(regionName); if (!isAlwaysTolerant) { toleratedSpaces = new HashSet<string>(props.GetQueryCacheRegionTolerance(regionName)); } }
public IQueryCache GetQueryCache(string regionName, UpdateTimestampsCache updateTimestampsCache, Settings settings, IDictionary<string, string> props) { Type queryCacheType = props.GetQueryCacheRegionResolver(regionName); if(queryCacheType == null) { return new StandardQueryCache(settings, props, updateTimestampsCache, regionName); } else { var args = new object[] {settings, props, updateTimestampsCache, regionName}; return queryCacheType.Instantiate<IQueryCache>(args); } }
/// <summary> /// Creates an <see cref="ICacheConcurrencyStrategy"/> from the parameters. /// </summary> /// <param name="usage">The name of the strategy that <see cref="ICacheProvider"/> should use for the class.</param> /// <param name="name">The name of the class the strategy is being created for.</param> /// <param name="mutable"><see langword="true" /> if the object being stored in the cache is mutable.</param> /// <param name="settings">Used to retrieve the global cache region prefix.</param> /// <param name="properties">Properties the cache provider can use to configure the cache.</param> /// <returns>An <see cref="ICacheConcurrencyStrategy"/> to use for this object in the <see cref="ICache"/>.</returns> public static ICacheConcurrencyStrategy CreateCache(string usage, string name, bool mutable, Settings settings, IDictionary<string,string> properties) { if (usage == null || !settings.IsSecondLevelCacheEnabled) return null; //no cache string prefix = settings.CacheRegionPrefix; if (prefix != null) name = prefix + '.' + name; if (log.IsDebugEnabled) { log.Debug(string.Format("cache for: {0} usage strategy: {1}", name, usage)); } ICacheConcurrencyStrategy ccs; switch (usage) { case ReadOnly: if (mutable) { log.Warn("read-only cache configured for mutable: " + name); } ccs = new ReadOnlyCache(); break; case ReadWrite: ccs = new ReadWriteCache(); break; case NonstrictReadWrite: ccs = new NonstrictReadWriteCache(); break; //case CacheFactory.Transactional: // ccs = new TransactionalCache(); // break; default: throw new MappingException( "cache usage attribute should be read-write, read-only, nonstrict-read-write, or transactional"); } ICache impl; try { impl = settings.CacheProvider.BuildCache(name, properties); } catch (CacheException e) { throw new HibernateException("Could not instantiate cache implementation", e); } ccs.Cache = impl; return ccs; }
public StandardQueryCache(Settings settings, IDictionary<string, string> props, UpdateTimestampsCache updateTimestampsCache, string regionName) { if (regionName == null) regionName = typeof (StandardQueryCache).FullName; String prefix = settings.CacheRegionPrefix; if (!string.IsNullOrEmpty(prefix)) regionName = prefix + '.' + regionName; Log.Info("starting query cache at region: " + regionName); _queryCache = settings.CacheProvider.BuildCache(regionName, props); _updateTimestampsCache = updateTimestampsCache; _regionName = regionName; }
public StandardQueryCache(Settings settings, IDictionary<string,string> props, UpdateTimestampsCache updateTimestampsCache, string regionName) { if (regionName == null) { regionName = typeof(StandardQueryCache).FullName; } String prefix = settings.CacheRegionPrefix; if (prefix != null) regionName = prefix + '.' + regionName; log.Info("starting query cache at region: " + regionName); queryCache = settings.CacheProvider.BuildCache(regionName, props); this.updateTimestampsCache = updateTimestampsCache; this.regionName = regionName; }
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 SessionFactoryImpl(Configuration cfg, IMapping mapping, Settings settings, EventListeners listeners) { Init(); log.Info("building session factory"); properties = new Dictionary<string, string>(cfg.Properties); interceptor = cfg.Interceptor; this.settings = settings; sqlFunctionRegistry = new SQLFunctionRegistry(settings.Dialect, cfg.SqlFunctions); eventListeners = listeners; filters = new Dictionary<string, FilterDefinition>(cfg.FilterDefinitions); if (log.IsDebugEnabled) { log.Debug("Session factory constructed with filter configurations : " + CollectionPrinter.ToString(filters)); } if (log.IsDebugEnabled) { log.Debug("instantiating session factory with properties: " + CollectionPrinter.ToString(properties)); } try { if (settings.IsKeywordsImportEnabled) { SchemaMetadataUpdater.Update(this); } if (settings.IsAutoQuoteEnabled) { SchemaMetadataUpdater.QuoteTableAndColumns(cfg); } } catch (NotSupportedException) { // Ignore if the Dialect does not provide DataBaseSchema } #region Caches settings.CacheProvider.Start(properties); #endregion #region Generators identifierGenerators = new Dictionary<string, IIdentifierGenerator>(); foreach (PersistentClass model in cfg.ClassMappings) { if (!model.IsInherited) { IIdentifierGenerator generator = model.Identifier.CreateIdentifierGenerator(settings.Dialect, settings.DefaultCatalogName, settings.DefaultSchemaName, (RootClass) model); identifierGenerators[model.EntityName] = generator; } } #endregion #region Persisters Dictionary<string, ICacheConcurrencyStrategy> caches = new Dictionary<string, ICacheConcurrencyStrategy>(); entityPersisters = new Dictionary<string, IEntityPersister>(); implementorToEntityName = new Dictionary<System.Type, string>(); Dictionary<string, IClassMetadata> classMeta = new Dictionary<string, IClassMetadata>(); foreach (PersistentClass model in cfg.ClassMappings) { model.PrepareTemporaryTables(mapping, settings.Dialect); string cacheRegion = model.RootClazz.CacheRegionName; ICacheConcurrencyStrategy cache; if (!caches.TryGetValue(cacheRegion, out cache)) { cache = CacheFactory.CreateCache(model.CacheConcurrencyStrategy, cacheRegion, model.IsMutable, settings, properties); if (cache != null) { caches.Add(cacheRegion, cache); allCacheRegions.Add(cache.RegionName, cache.Cache); } } IEntityPersister cp = PersisterFactory.CreateClassPersister(model, cache, this, mapping); entityPersisters[model.EntityName] = cp; classMeta[model.EntityName] = cp.ClassMetadata; if (model.HasPocoRepresentation) { implementorToEntityName[model.MappedClass] = model.EntityName; } } classMetadata = new UnmodifiableDictionary<string, IClassMetadata>(classMeta); Dictionary<string, ISet<string>> tmpEntityToCollectionRoleMap = new Dictionary<string, ISet<string>>(); collectionPersisters = new Dictionary<string, ICollectionPersister>(); foreach (Mapping.Collection model in cfg.CollectionMappings) { ICacheConcurrencyStrategy cache = CacheFactory.CreateCache(model.CacheConcurrencyStrategy, model.CacheRegionName, model.Owner.IsMutable, settings, properties); if (cache != null) { allCacheRegions[cache.RegionName] = cache.Cache; } ICollectionPersister persister = PersisterFactory.CreateCollectionPersister(cfg, model, cache, this); collectionPersisters[model.Role] = persister; IType indexType = persister.IndexType; if (indexType != null && indexType.IsAssociationType && !indexType.IsAnyType) { string entityName = ((IAssociationType) indexType).GetAssociatedEntityName(this); ISet<string> roles; if (!tmpEntityToCollectionRoleMap.TryGetValue(entityName, out roles)) { roles = new HashedSet<string>(); tmpEntityToCollectionRoleMap[entityName] = roles; } roles.Add(persister.Role); } IType elementType = persister.ElementType; if (elementType.IsAssociationType && !elementType.IsAnyType) { string entityName = ((IAssociationType) elementType).GetAssociatedEntityName(this); ISet<string> roles; if (!tmpEntityToCollectionRoleMap.TryGetValue(entityName, out roles)) { roles = new HashedSet<string>(); tmpEntityToCollectionRoleMap[entityName] = roles; } roles.Add(persister.Role); } } Dictionary<string, ICollectionMetadata> tmpcollectionMetadata = new Dictionary<string, ICollectionMetadata>(collectionPersisters.Count); foreach (KeyValuePair<string, ICollectionPersister> collectionPersister in collectionPersisters) { tmpcollectionMetadata.Add(collectionPersister.Key, collectionPersister.Value.CollectionMetadata); } collectionMetadata = new UnmodifiableDictionary<string, ICollectionMetadata>(tmpcollectionMetadata); collectionRolesByEntityParticipant = new UnmodifiableDictionary<string, ISet<string>>(tmpEntityToCollectionRoleMap); #endregion #region Named Queries namedQueries = new Dictionary<string, NamedQueryDefinition>(cfg.NamedQueries); namedSqlQueries = new Dictionary<string, NamedSQLQueryDefinition>(cfg.NamedSQLQueries); sqlResultSetMappings = new Dictionary<string, ResultSetMappingDefinition>(cfg.SqlResultSetMappings); #endregion imports = new Dictionary<string, string>(cfg.Imports); #region after *all* persisters and named queries are registered foreach (IEntityPersister persister in entityPersisters.Values) { persister.PostInstantiate(); } foreach (ICollectionPersister persister in collectionPersisters.Values) { persister.PostInstantiate(); } #endregion #region Serialization info name = settings.SessionFactoryName; try { uuid = (string) UuidGenerator.Generate(null, null); } catch (Exception) { throw new AssertionFailure("Could not generate UUID"); } SessionFactoryObjectFactory.AddInstance(uuid, name, this, properties); #endregion log.Debug("Instantiated session factory"); #region Schema management if (settings.IsAutoCreateSchema) { new SchemaExport(cfg).Create(false, true); } if ( settings.IsAutoUpdateSchema ) { new SchemaUpdate(cfg).Execute(false, true); } if (settings.IsAutoValidateSchema) { new SchemaValidator(cfg, settings).Validate(); } if (settings.IsAutoDropSchema) { schemaExport = new SchemaExport(cfg); } #endregion #region Obtaining TransactionManager // not ported yet #endregion currentSessionContext = BuildCurrentSessionContext(); if (settings.IsQueryCacheEnabled) { updateTimestampsCache = new UpdateTimestampsCache(settings, properties); queryCache = settings.QueryCacheFactory.GetQueryCache(null, updateTimestampsCache, settings, properties); queryCaches = new ThreadSafeDictionary<string, IQueryCache>(new Dictionary<string, IQueryCache>()); } else { updateTimestampsCache = null; queryCache = null; queryCaches = null; } #region Checking for named queries if (settings.IsNamedQueryStartupCheckingEnabled) { IDictionary<string, HibernateException> errors = CheckNamedQueries(); if (errors.Count > 0) { StringBuilder failingQueries = new StringBuilder("Errors in named queries: "); foreach (KeyValuePair<string, HibernateException> pair in errors) { failingQueries.Append('{').Append(pair.Key).Append('}'); log.Error("Error in named query: " + pair.Key, pair.Value); } throw new HibernateException(failingQueries.ToString()); } } #endregion Statistics.IsStatisticsEnabled = settings.IsStatisticsEnabled; // EntityNotFoundDelegate IEntityNotFoundDelegate enfd = cfg.EntityNotFoundDelegate; if (enfd == null) { enfd = new DefaultEntityNotFoundDelegate(); } entityNotFoundDelegate = enfd; }
public void BuildInternalProject(IList assemblies, IList mappings, IList configurations, IList basePaths) { AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve); this.basePaths = basePaths; this.assemblies = assemblies; basePaths.Add(AppDomain.CurrentDomain.BaseDirectory); LoadConfigurations(configurations); LoadAssemblies(assemblies); LoadMappings(mappings); factory = (ISessionFactoryImplementor)cfg.BuildSessionFactory(); settings = factory.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; }
public SessionFactoryImpl(Configuration cfg, IMapping mapping, Settings settings) { log.Info("building session factory"); this.properties = cfg.Properties; this.interceptor = cfg.Interceptor; this.settings = settings; this.sqlFunctionRegistry = new SQLFunctionRegistry(settings.Dialect, cfg.SqlFunctions); if (log.IsDebugEnabled) { log.Debug("instantiating session factory with properties: " + CollectionPrinter.ToString(properties)); } settings.CacheProvider.Start(properties); // Generators: identifierGenerators = new Hashtable(); foreach (PersistentClass model in cfg.ClassMappings) { if (!model.IsInherited) { // TODO H3: IIdentifierGenerator generator = model.Identifier.CreateIdentifierGenerator( settings.Dialect); // IIdentifierGenerator generator = model.Identifier.CreateIdentifierGenerator( // settings.Dialect, // settings.DefaultCatalogName, // settings.DefaultSchemaName, // (RootClass) model // ); identifierGenerators[model.MappedClass] = generator; } } // Persisters: IDictionary caches = new Hashtable(); classPersisters = new Hashtable(); classPersistersByName = new Hashtable(); IDictionary classMeta = new Hashtable(); foreach (PersistentClass model in cfg.ClassMappings) { string cacheRegion = model.RootClazz.CacheRegionName; ICacheConcurrencyStrategy cache = (ICacheConcurrencyStrategy) caches[cacheRegion]; if (cache == null) { cache = CacheFactory.CreateCache(model.CacheConcurrencyStrategy, cacheRegion, model.IsMutable, settings, properties); if (cache != null) { caches.Add(cacheRegion, cache); allCacheRegions.Add(cache.RegionName, cache.Cache); } } IEntityPersister cp = PersisterFactory.CreateClassPersister(model, cache, this, mapping); classPersisters[model.MappedClass] = cp; // Adds the "Namespace.ClassName" (FullClassname) as a lookup to get to the Persiter. // Most of the internals of NHibernate use this method to get to the Persister since // Model.Name is used in so many places. It would be nice to fix it up to be Model.TypeName // instead of just FullClassname classPersistersByName[model.Name] = cp; // Add in the AssemblyQualifiedName (includes version) as a lookup to get to the Persister. // In HQL the Imports are used to get from the Classname to the Persister. The // Imports provide the ability to jump from the Classname to the AssemblyQualifiedName. classPersistersByName[model.MappedClass.AssemblyQualifiedName] = cp; classMeta[model.MappedClass] = cp.ClassMetadata; } classMetadata = new Hashtable(classMeta); collectionPersisters = new Hashtable(); foreach (Mapping.Collection map in cfg.CollectionMappings) { ICacheConcurrencyStrategy cache = CacheFactory.CreateCache(map.CacheConcurrencyStrategy, map.CacheRegionName, map.Owner.IsMutable, settings, properties); if (cache != null) allCacheRegions[cache.RegionName] = cache.Cache; collectionPersisters[map.Role] = PersisterFactory .CreateCollectionPersister(map, cache, this) .CollectionMetadata; } collectionMetadata = new Hashtable(collectionPersisters); //TODO: // For databinding: //templates = XMLDatabinder.GetOutputStyleSheetTemplates( properties ); // serialization info name = settings.SessionFactoryName; try { uuid = (string) UuidGenerator.Generate(null, null); } catch (Exception) { throw new AssertionFailure("could not generate UUID"); } SessionFactoryObjectFactory.AddInstance(uuid, name, this, properties); // Named queries: // TODO: precompile and cache named queries namedQueries = new Hashtable(cfg.NamedQueries); namedSqlQueries = new Hashtable(cfg.NamedSQLQueries); sqlResultSetMappings = new Hashtable(cfg.SqlResultSetMappings); filters = new Hashtable(cfg.FilterDefinitions); imports = new Hashtable(cfg.Imports); // after *all* persisters and named queries are registered foreach (IEntityPersister persister in classPersisters.Values) { persister.PostInstantiate(); } foreach (ICollectionPersister persister in collectionPersisters.Values) { persister.PostInstantiate(); } log.Debug("Instantiated session factory"); if (settings.IsAutoCreateSchema) { new SchemaExport(cfg).Create(false, true); } /* if ( settings.IsAutoUpdateSchema ) { new SchemaUpdate( cfg ).Execute( false, true ); } */ if (settings.IsAutoDropSchema) { schemaExport = new SchemaExport(cfg); } // Obtaining TransactionManager - not ported from H2.1 currentSessionContext = BuildCurrentSessionContext(); if (settings.IsQueryCacheEnabled) { updateTimestampsCache = new UpdateTimestampsCache(settings, properties); queryCache = settings.QueryCacheFactory .GetQueryCache(null, updateTimestampsCache, settings, properties); queryCaches = Hashtable.Synchronized(new Hashtable()); } else { updateTimestampsCache = null; queryCache = null; queryCaches = null; } }
public SchemaValidator(Configuration cfg, Settings settings) { configuration = cfg; dialect = settings.Dialect; connectionHelper = new SuppliedConnectionProviderConnectionHelper(settings.ConnectionProvider); }
public SessionFactoryImpl(Configuration cfg, IMapping mapping, Settings settings, EventListeners listeners) { Init(); log.Info("building session factory"); properties = cfg.Properties; interceptor = cfg.Interceptor; this.settings = settings; sqlFunctionRegistry = new SQLFunctionRegistry(settings.Dialect, cfg.SqlFunctions); eventListeners = listeners; if (log.IsDebugEnabled) { log.Debug("instantiating session factory with properties: " + CollectionPrinter.ToString(properties)); } settings.CacheProvider.Start(properties); // Generators: identifierGenerators = new Hashtable(); foreach (PersistentClass model in cfg.ClassMappings) { if (!model.IsInherited) { IIdentifierGenerator generator = model.Identifier.CreateIdentifierGenerator(settings.Dialect, settings.DefaultCatalogName, settings.DefaultSchemaName, (RootClass) model); identifierGenerators[model.MappedClass] = generator; } } // Persisters: IDictionary caches = new Hashtable(); classPersisters = new Hashtable(); classPersistersByName = new Hashtable(); IDictionary classMeta = new Hashtable(); foreach (PersistentClass model in cfg.ClassMappings) { string cacheRegion = model.RootClazz.CacheRegionName; ICacheConcurrencyStrategy cache = (ICacheConcurrencyStrategy) caches[cacheRegion]; if (cache == null) { cache = CacheFactory.CreateCache(model.CacheConcurrencyStrategy, cacheRegion, model.IsMutable, settings, properties); if (cache != null) { caches.Add(cacheRegion, cache); allCacheRegions.Add(cache.RegionName, cache.Cache); } } IEntityPersister cp = PersisterFactory.CreateClassPersister(model, cache, this, mapping); classPersisters[model.MappedClass] = cp; // Adds the "Namespace.ClassName" (FullClassname) as a lookup to get to the Persiter. // Most of the internals of NHibernate use this method to get to the Persister since // Model.Name is used in so many places. It would be nice to fix it up to be Model.TypeName // instead of just FullClassname classPersistersByName[model.EntityName] = cp; // Add in the AssemblyQualifiedName (includes version) as a lookup to get to the Persister. // In HQL the Imports are used to get from the Classname to the Persister. The // Imports provide the ability to jump from the Classname to the AssemblyQualifiedName. classPersistersByName[model.MappedClass.AssemblyQualifiedName] = cp; classMeta[model.MappedClass] = cp.ClassMetadata; } classMetadata = new Hashtable(classMeta); IDictionary tmpEntityToCollectionRoleMap= new Hashtable(); collectionPersisters = new Hashtable(); foreach (Mapping.Collection map in cfg.CollectionMappings) { ICacheConcurrencyStrategy cache = CacheFactory.CreateCache(map.CacheConcurrencyStrategy, map.CacheRegionName, map.Owner.IsMutable, settings, properties); if (cache != null) allCacheRegions[cache.RegionName] = cache.Cache; collectionPersisters[map.Role] = PersisterFactory.CreateCollectionPersister(cfg, map, cache, this).CollectionMetadata; ICollectionPersister persister = collectionPersisters[map.Role] as ICollectionPersister; IType indexType = persister.IndexType; if (indexType != null && indexType.IsAssociationType && !indexType.IsAnyType) { string entityName = ((IAssociationType)indexType).GetAssociatedEntityName(this); ISet roles = tmpEntityToCollectionRoleMap[entityName] as ISet; if (roles == null) { roles = new HashedSet(); tmpEntityToCollectionRoleMap[entityName] = roles; } roles.Add(persister.Role); } IType elementType = persister.ElementType; if (elementType.IsAssociationType && !elementType.IsAnyType) { string entityName = ((IAssociationType)elementType).GetAssociatedEntityName(this); ISet roles = tmpEntityToCollectionRoleMap[entityName] as ISet; if (roles == null) { roles = new HashedSet(); tmpEntityToCollectionRoleMap[entityName] = roles; } roles.Add(persister.Role); } } collectionMetadata = new Hashtable(collectionPersisters); collectionRolesByEntityParticipant = new Hashtable(tmpEntityToCollectionRoleMap); //TODO: // For databinding: //templates = XMLDatabinder.GetOutputStyleSheetTemplates( properties ); // serialization info name = settings.SessionFactoryName; try { uuid = (string) UuidGenerator.Generate(null, null); } catch (Exception) { throw new AssertionFailure("could not generate UUID"); } SessionFactoryObjectFactory.AddInstance(uuid, name, this, properties); // Named queries: // TODO: precompile and cache named queries namedQueries = new Dictionary<string, NamedQueryDefinition>(cfg.NamedQueries); namedSqlQueries = new Dictionary<string, NamedSQLQueryDefinition>(cfg.NamedSQLQueries); sqlResultSetMappings = new Dictionary<string, ResultSetMappingDefinition>(cfg.SqlResultSetMappings); filters = new Dictionary<string, FilterDefinition>(cfg.FilterDefinitions); imports = new Dictionary<string, string>(cfg.Imports); // after *all* persisters and named queries are registered foreach (IEntityPersister persister in classPersisters.Values) { persister.PostInstantiate(); } foreach (ICollectionPersister persister in collectionPersisters.Values) { persister.PostInstantiate(); } log.Debug("Instantiated session factory"); if (settings.IsAutoCreateSchema) { new SchemaExport(cfg).Create(false, true); } /* if ( settings.IsAutoUpdateSchema ) { new SchemaUpdate( cfg ).Execute( false, true ); } */ if (settings.IsAutoDropSchema) { schemaExport = new SchemaExport(cfg); } // Obtaining TransactionManager - not ported from H2.1 currentSessionContext = BuildCurrentSessionContext(); if (settings.IsQueryCacheEnabled) { updateTimestampsCache = new UpdateTimestampsCache(settings, properties); queryCache = settings.QueryCacheFactory .GetQueryCache(null, updateTimestampsCache, settings, properties); queryCaches = Hashtable.Synchronized(new Hashtable()); } else { updateTimestampsCache = null; queryCache = null; queryCaches = null; } //checking for named queries if (settings.IsNamedQueryStartupCheckingEnabled) { IDictionary<string, HibernateException> errors = CheckNamedQueries(); if (errors.Count > 0) { StringBuilder failingQueries = new StringBuilder("Errors in named queries: "); foreach (KeyValuePair<string, HibernateException> pair in errors) { failingQueries.Append('{').Append(pair.Key).Append('}'); log.Error("Error in named query: " + pair.Key, pair.Value); } throw new HibernateException(failingQueries.ToString()); } } Statistics.IsStatisticsEnabled = settings.IsStatisticsEnabled; // EntityNotFoundDelegate IEntityNotFoundDelegate enfd = cfg.EntityNotFoundDelegate; if (enfd == null) { enfd = new DefaultEntityNotFoundDelegate(); } entityNotFoundDelegate = enfd; }
public ProjectionEnabledQueryCache(Settings settings, IDictionary<string, string> props, UpdateTimestampsCache updateTimestampsCache, string regionName) : base(settings, props, updateTimestampsCache, regionName) { }
protected void ConfigureCaches( Settings settings ) { //TODO: this is actually broken, I guess, since changing the // cache provider property and rebuilding the SessionFactory // will affect existing SessionFactory! log.Info( "instantiating and configuring caches" ); // needed here because caches are built directly below. This is fixed in H3. settings.CacheProvider.Start( properties ); string prefix = properties[ Environment.CacheRegionPrefix ] as string; foreach( DictionaryEntry de in caches ) { string name = ( string ) de.Key; if( prefix != null ) { name = prefix + "." + name; } ICacheConcurrencyStrategy strategy = ( ICacheConcurrencyStrategy ) de.Value; if( log.IsDebugEnabled ) { log.Debug( "instantiating cache " + name ); } ICache cache; try { cache = settings.CacheProvider.BuildCache( name, properties ); } catch( CacheException ce ) { throw new HibernateException( "Could not instantiate Cache", ce ); } strategy.Cache = cache; strategy.MinimalPuts = settings.IsMinimalPutsEnabled; } caches.Clear(); }
/// <summary> /// /// </summary> /// <param name="cfg"></param> /// <param name="settings"></param> public SessionFactoryImpl( Configuration cfg, Settings settings ) { log.Info( "building session factory" ); this.properties = cfg.Properties; this.interceptor = cfg.Interceptor; this.settings = settings; if( log.IsDebugEnabled ) { log.Debug( "instantiating session factory with properties: " + CollectionPrinter.ToString( properties ) ); } // Persisters: classPersisters = new Hashtable(); classPersistersByName = new Hashtable(); IDictionary classMeta = new Hashtable(); foreach( PersistentClass model in cfg.ClassMappings ) { IClassPersister cp = PersisterFactory.CreateClassPersister( model, this ); classPersisters[ model.MappedClass ] = cp; // Adds the "Namespace.ClassName" (FullClassname) as a lookup to get to the Persiter. // Most of the internals of NHibernate use this method to get to the Persister since // Model.Name is used in so many places. It would be nice to fix it up to be Model.TypeName // instead of just FullClassname classPersistersByName[ model.Name ] = cp; // Add in the AssemblyQualifiedName (includes version) as a lookup to get to the Persister. // In HQL the Imports are used to get from the Classname to the Persister. The // Imports provide the ability to jump from the Classname to the AssemblyQualifiedName. classPersistersByName[ model.MappedClass.AssemblyQualifiedName ] = cp; classMeta[ model.MappedClass ] = cp.ClassMetadata; } classMetadata = new Hashtable( classMeta ); collectionPersisters = new Hashtable(); foreach( Mapping.Collection map in cfg.CollectionMappings ) { collectionPersisters[ map.Role ] = PersisterFactory .CreateCollectionPersister( map, this ) .CollectionMetadata; } collectionMetadata = new Hashtable( collectionPersisters ); // after *all* persisters are registered foreach( IClassPersister persister in classPersisters.Values ) { // TODO: H2.1 doesn't pass this to PostInstantiate persister.PostInstantiate( this ); } //TODO: // For databinding: //templates = XMLDatabinder.GetOutputStyleSheetTemplates( properties ); // serialization info name = settings.SessionFactoryName; try { uuid = ( string ) UuidGenerator.Generate( null, null ); } catch( Exception ) { throw new AssertionFailure( "could not generate UUID" ); } SessionFactoryObjectFactory.AddInstance( uuid, name, this, properties ); // Named queries: // TODO: precompile and cache named queries namedQueries = new Hashtable( cfg.NamedQueries ); namedSqlQueries = new Hashtable( cfg.NamedSQLQueries.Count ); foreach( DictionaryEntry de in cfg.NamedSQLQueries ) { NamedSQLQuery nsq = ( NamedSQLQuery ) de.Value; namedSqlQueries[ de.Key ] = new InternalNamedSQLQuery( nsq.QueryString, nsq.ReturnAliases, nsq.ReturnClasses, nsq.SynchronizedTables ); } imports = new Hashtable( cfg.Imports ); log.Debug( "Instantiated session factory" ); if( settings.IsAutoCreateSchema ) { new SchemaExport( cfg ).Create( false, true ); } /* if ( settings.IsAutoUpdateSchema ) { new SchemaUpdate( cfg ).Execute( false, true ); } */ if( settings.IsAutoDropSchema ) { schemaExport = new SchemaExport( cfg ); } // Obtaining TransactionManager - not ported from H2.1 if( settings.IsQueryCacheEnabled ) { updateTimestampsCache = new UpdateTimestampsCache( settings.CacheProvider, properties ); queryCache = settings.QueryCacheFactory .GetQueryCache( null, settings.CacheProvider, updateTimestampsCache, properties ); queryCaches = Hashtable.Synchronized( new Hashtable() ); } else { updateTimestampsCache = null; queryCache = null; queryCaches = null; } }