/// <summary> /// Build a query cache. /// </summary> /// <param name="factory">The query cache factory.</param> /// <param name="updateTimestampsCache">The cache of updates timestamps.</param> /// <param name="props">The NHibernate settings properties.</param> /// <param name="regionCache">The <see cref="ICache" /> to use for the region.</param> /// <returns>A query cache. <c>null</c> if <paramref name="factory"/> does not implement a /// <c>public IQueryCache GetQueryCache(UpdateTimestampsCache, IDictionary<string, string> props, CacheBase)</c> /// method.</returns> public static IQueryCache GetQueryCache( this IQueryCacheFactory factory, UpdateTimestampsCache updateTimestampsCache, IDictionary <string, string> props, CacheBase regionCache) { if (factory is StandardQueryCacheFactory standardFactory) { return(standardFactory.GetQueryCache(updateTimestampsCache, props, regionCache)); } // Use reflection for supporting custom factories. var factoryType = factory.GetType(); var getQueryCacheMethod = factoryType.GetMethod( nameof(StandardQueryCacheFactory.GetQueryCache), new[] { typeof(UpdateTimestampsCache), typeof(IDictionary <string, string>), typeof(CacheBase) }); if (getQueryCacheMethod != null) { return((IQueryCache)getQueryCacheMethod.Invoke( factory, new object[] { updateTimestampsCache, props, regionCache })); } // Caller has to call the obsolete method. Logger.Warn( "{0} does not implement 'IQueryCache GetQueryCache(UpdateTimestampsCache, IDictionary<string, " + "string> props, CacheBase)', its obsolete overload will be used.", factoryType); return(null); }
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 IQueryCache GetQueryCache(string regionName, UpdateTimestampsCache updateTimestampsCache, Settings settings, IDictionary <string, string> props) { return(new StandardQueryCache(settings, props, updateTimestampsCache, regionName)); }
/// <summary> /// Build a query cache. /// </summary> /// <param name="updateTimestampsCache">The cache of updates timestamps.</param> /// <param name="props">The NHibernate settings properties.</param> /// <param name="regionCache">The <see cref="CacheBase" /> to use for the region.</param> /// <returns>A query cache.</returns> public virtual IQueryCache GetQueryCache( UpdateTimestampsCache updateTimestampsCache, IDictionary <string, string> props, CacheBase regionCache) { return(new StandardQueryCache(updateTimestampsCache, regionCache)); }
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 StandardQueryCache( ICacheProvider provider, IDictionary props, UpdateTimestampsCache updateTimestampsCache, string regionName ) { if( regionName == null ) { regionName = typeof( StandardQueryCache ).FullName; } log.Info( "starting query cache at region: " + regionName ); this.queryCache = provider.BuildCache( regionName, props ); this.updateTimestampsCache = updateTimestampsCache; this.regionName = regionName; }
public StandardQueryCache(ICacheProvider provider, IDictionary props, UpdateTimestampsCache updateTimestampsCache, string regionName) { if (regionName == null) { regionName = typeof(StandardQueryCache).FullName; } log.Info("starting query cache at region: " + regionName); this.queryCache = provider.BuildCache(regionName, props); this.updateTimestampsCache = updateTimestampsCache; this.regionName = 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> /// Build a query cache. /// </summary> /// <param name="updateTimestampsCache">The cache of updates timestamps.</param> /// <param name="regionCache">The <see cref="ICache" /> to use for the region.</param> public StandardQueryCache( UpdateTimestampsCache updateTimestampsCache, CacheBase regionCache) { if (regionCache == null) throw new ArgumentNullException(nameof(regionCache)); _regionName = regionCache.RegionName; Log.Info("starting query cache at region: {0}", _regionName); _cache = regionCache; _updateTimestampsCache = updateTimestampsCache; }
public StandardQueryCache( Settings settings, IDictionary <string, string> props, UpdateTimestampsCache updateTimestampsCache, string regionName) : this( updateTimestampsCache, CacheFactory.BuildCacheBase( settings.GetFullCacheRegionName(regionName ?? typeof(StandardQueryCache).FullName), settings, props)) { }
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 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 (!string.IsNullOrEmpty(prefix)) { regionName = prefix + '.' + regionName; } log.Info("starting query cache at region: " + regionName); queryCache = settings.CacheProvider.BuildCache(regionName, props); this.updateTimestampsCache = updateTimestampsCache; this.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 (!string.IsNullOrEmpty(prefix)) { regionName = prefix + '.' + regionName; } Log.Info("starting query cache at region: {0}", regionName); _queryCache = settings.CacheProvider.BuildCache(regionName, props); _batchableReadOnlyCache = _queryCache as IBatchableReadOnlyCache; _batchableCache = _queryCache as IBatchableCache; _updateTimestampsCache = updateTimestampsCache; _regionName = regionName; }
public StandardQueryCache(Settings settings, IDictionary <string, string> props, UpdateTimestampsCache updateTimestampsCache, string regionName) { if (regionName == null) { regionName = typeof(StandardQueryCache).FullName; } var prefix = settings.CacheRegionPrefix; if (!string.IsNullOrEmpty(prefix)) { regionName = prefix + '.' + regionName; } Log.Info("starting query cache at region: {0}", regionName); Cache = settings.CacheProvider.BuildCache(regionName, props); _cache = Cache as CacheBase ?? new ObsoleteCacheWrapper(Cache); _updateTimestampsCache = updateTimestampsCache; _regionName = regionName; }
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; }
/// <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; } }
public IQueryCache GetQueryCache( string regionName, ICacheProvider provider, UpdateTimestampsCache updateTimestampsCache, IDictionary props ) { return new StandardQueryCache( provider, props, updateTimestampsCache, regionName ); }
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 IQueryCache GetQueryCache(string regionName, ICacheProvider provider, UpdateTimestampsCache updateTimestampsCache, IDictionary props) { return(new StandardQueryCache(provider, props, updateTimestampsCache, regionName)); }
public ProjectionEnabledQueryCache(Settings settings, IDictionary<string, string> props, UpdateTimestampsCache updateTimestampsCache, string regionName) : base(settings, props, updateTimestampsCache, regionName) { }
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; }