/// <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&lt;string, string&gt; 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&lt;string, " +
                "string&gt; 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;
		}
Beispiel #8
0
 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))
 {
 }
Beispiel #12
0
		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;
        }
Beispiel #16
0
        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;
			}
		}
Beispiel #21
0
 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)
 {
 }
Beispiel #23
0
		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;
		}