public void SetupSagaPersisterContext()
 {
     DeleteFile();
     CurrentSessionContext = new ThreadStaticCurrentSessionContext();
     SessionFactory = new HostedServerSessionFactory(CurrentSessionContext, DbFileName);
     _storage = new Db4oSubscriptionStorage(SessionFactory);
 }
Exemple #2
0
        private ICurrentSessionContext BuildCurrentSessionContext()
        {
            var impl = System.Configuration.ConfigurationManager.AppSettings["sessionContextType"];

            ICurrentSessionContext result = null;

            switch (impl)
            {
            case "CallSessionContext":
                result = new CallSessionContext(this);
                break;

            case "ThreadStaticSessionContext":
                result = new ThreadStaticSessionContext(this);
                break;

            case "WebSessionContext":
                result = new WebSessionContext(this);
                break;

            case "ManagedWebSessionContext":
                result = new ManagedWebSessionContext(this);
                break;
            }
            return(result);
        }
 public void SetupContext()
 {
     CurrentSessionContext = new ThreadStaticCurrentSessionContext();
     Server = Db4oClientServer.OpenServer(Db4oClientServer.NewServerConfiguration(), "RemoteServerTestDb.yap", Port);
     Server.GrantAccess(Username,Password);
     SessionFactory = new RemoteServerSessionFactory(CurrentSessionContext,Host, Port, Username, Password);
 }
 public static Configure Db4oRemoteDatabase(this Configure config,
     ICurrentSessionContext currentSessionContext, Func<IClientConfiguration> clientConfig, 
     string host, int port, string username, string password)
 {
     var sessionFactory = new RemoteServerSessionFactory(currentSessionContext, clientConfig, host, port, username, password);
     config.Configurer.RegisterSingleton<ISessionFactory>(sessionFactory);
     return config;
 }
 public static Configure Db4oHostedDatabase(this Configure config, 
     ICurrentSessionContext currentSessionContext, IServerConfiguration serverConfig, 
     string dbFileName, int port, params HostedServerSessionFactory.Access[] access)
 {
     var sessionFactory = new HostedServerSessionFactory(currentSessionContext, serverConfig, dbFileName, port, access);
     config.Configurer.RegisterSingleton<ISessionFactory>(sessionFactory);
     return config;
 }
 public RemoteServerSessionFactory(ICurrentSessionContext currentSessionContext, Func<IClientConfiguration> config, string host, int port, string username, string password)
     : base(currentSessionContext)
 {
     _config = config;
     _host = host;
     _port = port;
     _username = username;
     _password = password;
 }
        /// <summary>
        /// Allows configuration of the server and opening to the outside
        /// </summary>
        public HostedServerSessionFactory(ICurrentSessionContext currentSessionContext, IServerConfiguration config, string dbFileName, int port, params Access[] access)
            : base(currentSessionContext)
        {
            _server = Db4oClientServer.OpenServer(config, dbFileName, port);

            foreach(var account in access)
            {
                _server.GrantAccess(account.Username,account.Password);
            }
        }
Exemple #8
0
        public SessionFactoryImpl(Configuration cfg, Settings settings)
        {
            this.settings = settings;

            //settings.CacheProvider.Start(null);

            #region Persisters

            entityPersisters = new Dictionary <string, IEntityPersister>();
            foreach (ClassMetadata model in cfg.ClassMappings)
            {
                //string cacheRegion = model.EntityName;
                //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);
                //    }
                //}

                IEntityPersister cp = new EntityPersister(model, this);  // PersisterFactory.CreateClassPersister(model, cache, this, mapping);
                entityPersisters[model.EntityName] = cp;
            }

            #endregion

            #region Serialization info

            name = settings.SessionFactoryName;

            uuid = Guid.NewGuid().ToString("N");

            SessionFactoryObjectFactory.AddInstance(uuid, name, this);

            #endregion

            currentSessionContext = BuildCurrentSessionContext();
        }
		public SessionFactoryImpl(Configuration cfg, IMapping mapping, Settings settings, EventListeners listeners)
		{
			Init();
			log.Info("building session factory");

			properties = new Dictionary<string, string>(cfg.Properties);
			interceptor = cfg.Interceptor;
			this.settings = settings;
			sqlFunctionRegistry = new SQLFunctionRegistry(settings.Dialect, cfg.SqlFunctions);
			eventListeners = listeners;
			filters = new Dictionary<string, FilterDefinition>(cfg.FilterDefinitions);
			if (log.IsDebugEnabled)
			{
				log.Debug("Session factory constructed with filter configurations : " + CollectionPrinter.ToString(filters));
			}

			if (log.IsDebugEnabled)
			{
				log.Debug("instantiating session factory with properties: " + CollectionPrinter.ToString(properties));
			}

			try
			{
				if (settings.IsKeywordsImportEnabled)
				{
					SchemaMetadataUpdater.Update(this);
				}
				if (settings.IsAutoQuoteEnabled)
				{
					SchemaMetadataUpdater.QuoteTableAndColumns(cfg);
				}
			}
			catch (NotSupportedException)
			{
				// Ignore if the Dialect does not provide DataBaseSchema 
			}

			#region Caches
			settings.CacheProvider.Start(properties);
			#endregion

			#region Generators
			identifierGenerators = new Dictionary<string, IIdentifierGenerator>();
			foreach (PersistentClass model in cfg.ClassMappings)
			{
				if (!model.IsInherited)
				{
					IIdentifierGenerator generator =
						model.Identifier.CreateIdentifierGenerator(settings.Dialect, settings.DefaultCatalogName,
						                                           settings.DefaultSchemaName, (RootClass) model);

					identifierGenerators[model.EntityName] = generator;
				}
			}
			#endregion

			#region Persisters

			Dictionary<string, ICacheConcurrencyStrategy> caches = new Dictionary<string, ICacheConcurrencyStrategy>();
			entityPersisters = new Dictionary<string, IEntityPersister>();
			implementorToEntityName = new Dictionary<System.Type, string>();

			Dictionary<string, IClassMetadata> classMeta = new Dictionary<string, IClassMetadata>();

			foreach (PersistentClass model in cfg.ClassMappings)
			{
				model.PrepareTemporaryTables(mapping, settings.Dialect);
				string cacheRegion = model.RootClazz.CacheRegionName;
				ICacheConcurrencyStrategy cache;
				if (!caches.TryGetValue(cacheRegion, out cache))
				{
					cache =
						CacheFactory.CreateCache(model.CacheConcurrencyStrategy, cacheRegion, model.IsMutable, settings, properties);
					if (cache != null)
					{
						caches.Add(cacheRegion, cache);
						allCacheRegions.Add(cache.RegionName, cache.Cache);
					}
				}
				IEntityPersister cp = PersisterFactory.CreateClassPersister(model, cache, this, mapping);
				entityPersisters[model.EntityName] = cp;
				classMeta[model.EntityName] = cp.ClassMetadata;

				if (model.HasPocoRepresentation)
				{
					implementorToEntityName[model.MappedClass] = model.EntityName;
				}
			}
			classMetadata = new UnmodifiableDictionary<string, IClassMetadata>(classMeta);

			Dictionary<string, ISet<string>> tmpEntityToCollectionRoleMap = new Dictionary<string, ISet<string>>();
			collectionPersisters = new Dictionary<string, ICollectionPersister>();
			foreach (Mapping.Collection model in cfg.CollectionMappings)
			{
				ICacheConcurrencyStrategy cache =
					CacheFactory.CreateCache(model.CacheConcurrencyStrategy, model.CacheRegionName, model.Owner.IsMutable, settings,
					                         properties);
				if (cache != null)
				{
					allCacheRegions[cache.RegionName] = cache.Cache;
				}
				ICollectionPersister persister = PersisterFactory.CreateCollectionPersister(cfg, model, cache, this);
				collectionPersisters[model.Role] = persister;
				IType indexType = persister.IndexType;
				if (indexType != null && indexType.IsAssociationType && !indexType.IsAnyType)
				{
					string entityName = ((IAssociationType) indexType).GetAssociatedEntityName(this);
					ISet<string> roles;
					if (!tmpEntityToCollectionRoleMap.TryGetValue(entityName, out roles))
					{
						roles = new HashedSet<string>();
						tmpEntityToCollectionRoleMap[entityName] = roles;
					}
					roles.Add(persister.Role);
				}
				IType elementType = persister.ElementType;
				if (elementType.IsAssociationType && !elementType.IsAnyType)
				{
					string entityName = ((IAssociationType) elementType).GetAssociatedEntityName(this);
					ISet<string> roles;
					if (!tmpEntityToCollectionRoleMap.TryGetValue(entityName, out roles))
					{
						roles = new HashedSet<string>();
						tmpEntityToCollectionRoleMap[entityName] = roles;
					}
					roles.Add(persister.Role);
				}
			}
			Dictionary<string, ICollectionMetadata> tmpcollectionMetadata = new Dictionary<string, ICollectionMetadata>(collectionPersisters.Count);
			foreach (KeyValuePair<string, ICollectionPersister> collectionPersister in collectionPersisters)
			{
				tmpcollectionMetadata.Add(collectionPersister.Key, collectionPersister.Value.CollectionMetadata);
			}
			collectionMetadata = new UnmodifiableDictionary<string, ICollectionMetadata>(tmpcollectionMetadata);
			collectionRolesByEntityParticipant = new UnmodifiableDictionary<string, ISet<string>>(tmpEntityToCollectionRoleMap);
			#endregion

			#region Named Queries
			namedQueries = new Dictionary<string, NamedQueryDefinition>(cfg.NamedQueries);
			namedSqlQueries = new Dictionary<string, NamedSQLQueryDefinition>(cfg.NamedSQLQueries);
			sqlResultSetMappings = new Dictionary<string, ResultSetMappingDefinition>(cfg.SqlResultSetMappings);
			#endregion

			imports = new Dictionary<string, string>(cfg.Imports);

			#region after *all* persisters and named queries are registered
			foreach (IEntityPersister persister in entityPersisters.Values)
			{
				persister.PostInstantiate();
			}
			foreach (ICollectionPersister persister in collectionPersisters.Values)
			{
				persister.PostInstantiate();
			}
			#endregion

			#region Serialization info

			name = settings.SessionFactoryName;
			try
			{
				uuid = (string) UuidGenerator.Generate(null, null);
			}
			catch (Exception)
			{
				throw new AssertionFailure("Could not generate UUID");
			}

			SessionFactoryObjectFactory.AddInstance(uuid, name, this, properties);

			#endregion

			log.Debug("Instantiated session factory");

			#region Schema management
			if (settings.IsAutoCreateSchema)
			{
				new SchemaExport(cfg).Create(false, true);
			}

			if ( settings.IsAutoUpdateSchema )
			{
				new SchemaUpdate(cfg).Execute(false, true);
			}
			if (settings.IsAutoValidateSchema)
			{
				 new SchemaValidator(cfg, settings).Validate();
			}
			if (settings.IsAutoDropSchema)
			{
				schemaExport = new SchemaExport(cfg);
			}
			#endregion

			#region Obtaining TransactionManager
			// not ported yet
			#endregion

			currentSessionContext = BuildCurrentSessionContext();

			if (settings.IsQueryCacheEnabled)
			{
				updateTimestampsCache = new UpdateTimestampsCache(settings, properties);
				queryCache = settings.QueryCacheFactory.GetQueryCache(null, updateTimestampsCache, settings, properties);
				queryCaches = new ThreadSafeDictionary<string, IQueryCache>(new Dictionary<string, IQueryCache>());
			}
			else
			{
				updateTimestampsCache = null;
				queryCache = null;
				queryCaches = null;
			}

			#region Checking for named queries
			if (settings.IsNamedQueryStartupCheckingEnabled)
			{
				IDictionary<string, HibernateException> errors = CheckNamedQueries();
				if (errors.Count > 0)
				{
					StringBuilder failingQueries = new StringBuilder("Errors in named queries: ");
					foreach (KeyValuePair<string, HibernateException> pair in errors)
					{
						failingQueries.Append('{').Append(pair.Key).Append('}');
						log.Error("Error in named query: " + pair.Key, pair.Value);
					}
					throw new HibernateException(failingQueries.ToString());
				}
			}
			#endregion

			Statistics.IsStatisticsEnabled = settings.IsStatisticsEnabled;

			// EntityNotFoundDelegate
			IEntityNotFoundDelegate enfd = cfg.EntityNotFoundDelegate;
			if (enfd == null)
			{
				enfd = new DefaultEntityNotFoundDelegate();
			}
			entityNotFoundDelegate = enfd;
		}
        public SessionFactoryImpl(Configuration cfg, Settings settings)
        {
            this.settings = settings;

            //settings.CacheProvider.Start(null);

            #region Persisters

            entityPersisters = new Dictionary<string, IEntityPersister>();
            foreach (ClassMetadata model in cfg.ClassMappings)
            {
                //string cacheRegion = model.EntityName;
                //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);
                //    }
                //}

                IEntityPersister cp = new EntityPersister(model, this);  // PersisterFactory.CreateClassPersister(model, cache, this, mapping);
                entityPersisters[model.EntityName] = cp;
            }

            #endregion

            #region Serialization info

            name = settings.SessionFactoryName;

            uuid = Guid.NewGuid().ToString("N");

            SessionFactoryObjectFactory.AddInstance(uuid, name, this);

            #endregion

            currentSessionContext = BuildCurrentSessionContext();
        }
 public DynamicRepository(IEntityConfigurationStore entityConfigurationStore, ICurrentSessionContext currentSessionContext)
 {
     _entityConfigurationStore = entityConfigurationStore;
     _currentSessionContext    = currentSessionContext;
 }
 /// <summary>
 /// Singleton constructor... constructs this singleton when 
 /// caller invokes Init() method with valid connection name...
 /// </summary>
 /// <param name="p_cnnName"></param>      
 public SessionFactory(string p_cnnName)
 {
     Init(p_cnnName);
     currentSessionContext = BuildCurrentSessionContext();
 }
 protected SessionFactoryBase(ICurrentSessionContext currentSessionContext)
 {
     _currentSessionContext = currentSessionContext;
 }
 /// <summary>
 /// Creates a hosted server that is only accessible in process
 /// </summary>
 public HostedServerSessionFactory(ICurrentSessionContext currentSessionContext, string dbFileName)
     : this(currentSessionContext, Db4oClientServer.NewServerConfiguration(), dbFileName,0)
 {
 }
 public void SetupSagaPersisterContext()
 {
     CurrentSessionContext = new ThreadStaticCurrentSessionContext();
     SessionFactory = new HostedServerSessionFactory(CurrentSessionContext, DbFileName);
     SagaPersister = new Db4oSagaPersister(SessionFactory);
 }
 public RemoteServerSessionFactory(ICurrentSessionContext currentSessionContext, string host, int port, string username, string password)
     : this(currentSessionContext, Db4oClientServer.NewClientConfiguration,host,port,username,password)
 {
 }
 public void SetupContext()
 {
     CurrentSessionContext = new ThreadStaticCurrentSessionContext();
     SessionFactory = new HostedServerSessionFactory(CurrentSessionContext,DbFileName);
 }
Exemple #18
0
 public UnitOfWorkSessionProvider(ICurrentSessionContext sessionContext)
 {
     _sessionContext = sessionContext;
 }
Exemple #19
0
        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 HashSet <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 HashSet <string>();
                        tmpEntityToCollectionRoleMap[entityName] = roles;
                    }
                    roles.Add(persister.Role);
                }
            }
            Dictionary <string, ICollectionMetadata> tmpcollectionMetadata = new Dictionary <string, ICollectionMetadata>(collectionPersisters.Count);
            foreach (KeyValuePair <string, ICollectionPersister> collectionPersister in collectionPersisters)
            {
                tmpcollectionMetadata.Add(collectionPersister.Key, collectionPersister.Value.CollectionMetadata);
            }
            collectionMetadata = new UnmodifiableDictionary <string, ICollectionMetadata>(tmpcollectionMetadata);
            collectionRolesByEntityParticipant = new UnmodifiableDictionary <string, ISet <string> >(tmpEntityToCollectionRoleMap);
            #endregion

            #region Named Queries
            namedQueries         = new Dictionary <string, NamedQueryDefinition>(cfg.NamedQueries);
            namedSqlQueries      = new Dictionary <string, NamedSQLQueryDefinition>(cfg.NamedSQLQueries);
            sqlResultSetMappings = new Dictionary <string, ResultSetMappingDefinition>(cfg.SqlResultSetMappings);
            #endregion

            imports = new Dictionary <string, string>(cfg.Imports);

            #region after *all* persisters and named queries are registered
            foreach (IEntityPersister persister in entityPersisters.Values)
            {
                persister.PostInstantiate();
            }
            foreach (ICollectionPersister persister in collectionPersisters.Values)
            {
                persister.PostInstantiate();
            }
            #endregion

            #region Serialization info

            name = settings.SessionFactoryName;
            try
            {
                uuid = (string)UuidGenerator.Generate(null, null);
            }
            catch (Exception)
            {
                throw new AssertionFailure("Could not generate UUID");
            }

            SessionFactoryObjectFactory.AddInstance(uuid, name, this, properties);

            #endregion

            log.Debug("Instantiated session factory");

            #region Schema management
            if (settings.IsAutoCreateSchema)
            {
                new SchemaExport(cfg).Create(false, true);
            }

            if (settings.IsAutoUpdateSchema)
            {
                new SchemaUpdate(cfg).Execute(false, true);
            }
            if (settings.IsAutoValidateSchema)
            {
                new SchemaValidator(cfg, settings).Validate();
            }
            if (settings.IsAutoDropSchema)
            {
                schemaExport = new SchemaExport(cfg);
            }
            #endregion

            #region Obtaining TransactionManager
            // not ported yet
            #endregion

            currentSessionContext = BuildCurrentSessionContext();

            if (settings.IsQueryCacheEnabled)
            {
                updateTimestampsCache = new UpdateTimestampsCache(settings, properties);
                queryCache            = settings.QueryCacheFactory.GetQueryCache(null, updateTimestampsCache, settings, properties);
                queryCaches           = new ThreadSafeDictionary <string, IQueryCache>(new Dictionary <string, IQueryCache>());
            }
            else
            {
                updateTimestampsCache = null;
                queryCache            = null;
                queryCaches           = null;
            }

            #region Checking for named queries
            if (settings.IsNamedQueryStartupCheckingEnabled)
            {
                IDictionary <string, HibernateException> errors = CheckNamedQueries();
                if (errors.Count > 0)
                {
                    StringBuilder failingQueries = new StringBuilder("Errors in named queries: ");
                    foreach (KeyValuePair <string, HibernateException> pair in errors)
                    {
                        failingQueries.Append('{').Append(pair.Key).Append('}');
                        log.Error("Error in named query: " + pair.Key, pair.Value);
                    }
                    throw new HibernateException(failingQueries.ToString());
                }
            }
            #endregion

            Statistics.IsStatisticsEnabled = settings.IsStatisticsEnabled;

            // EntityNotFoundDelegate
            IEntityNotFoundDelegate enfd = cfg.EntityNotFoundDelegate;
            if (enfd == null)
            {
                enfd = new DefaultEntityNotFoundDelegate();
            }
            entityNotFoundDelegate = enfd;
        }
        public 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;
        }