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