/// <summary> /// Retrieve multiple query results from the cache. /// </summary> /// <param name="queryCache">The cache.</param> /// <param name="keys">The query keys.</param> /// <param name="queryParameters">The array of query parameters matching <paramref name="keys"/>.</param> /// <param name="returnTypes">The array of query result row types matching <paramref name="keys"/>.</param> /// <param name="spaces">The array of query spaces matching <paramref name="keys"/>.</param> /// <param name="session">The session for which the queries are executed.</param> /// <returns>The cached query results, matching each key of <paramref name="keys"/> respectively. For each /// missed key, it will contain a <see langword="null" />.</returns> public static IList[] GetMany( this IQueryCache queryCache, QueryKey[] keys, QueryParameters[] queryParameters, ICacheAssembler[][] returnTypes, ISet <string>[] spaces, ISessionImplementor session) { if (queryCache is IBatchableQueryCache batchableQueryCache) { return(batchableQueryCache.GetMany( keys, queryParameters, returnTypes, spaces, session)); } var results = new IList[keys.Length]; for (var i = 0; i < keys.Length; i++) { results[i] = queryCache.Get(keys[i], queryParameters[i], returnTypes[i], spaces[i], session); } return(results); }
/// <summary> /// Put query results in the cache. /// </summary> /// <param name="queryCache">The cache.</param> /// <param name="key">The query key.</param> /// <param name="queryParameters">The query parameters.</param> /// <param name="returnTypes">The query result row types.</param> /// <param name="result">The query result.</param> /// <param name="session">The session for which the query was executed.</param> /// <returns><see langword="true" /> if the result has been cached, <see langword="false" /> /// otherwise.</returns> public static bool Put( this IQueryCache queryCache, QueryKey key, QueryParameters queryParameters, ICacheAssembler[] returnTypes, IList result, ISessionImplementor session) { if (queryCache is IBatchableQueryCache batchableQueryCache) { return(batchableQueryCache.Put( key, queryParameters, returnTypes, result, session)); } #pragma warning disable 618 return(queryCache.Put( #pragma warning restore 618 key, returnTypes, result, queryParameters.NaturalKeyLookup, session)); }
/// <summary> /// Attempt to cache objects, after loading them from the database. /// </summary> /// <param name="queryCache">The cache.</param> /// <param name="keys">The query keys.</param> /// <param name="queryParameters">The array of query parameters matching <paramref name="keys"/>.</param> /// <param name="returnTypes">The array of query result row types matching <paramref name="keys"/>.</param> /// <param name="results">The array of query results matching <paramref name="keys"/>.</param> /// <param name="session">The session for which the queries were executed.</param> /// <returns>An array of boolean indicating if each query was successfully cached.</returns> /// <exception cref="CacheException"></exception> public static bool[] PutMany( this IQueryCache queryCache, QueryKey[] keys, QueryParameters[] queryParameters, ICacheAssembler[][] returnTypes, IList[] results, ISessionImplementor session) { if (queryCache is IBatchableQueryCache batchableQueryCache) { return(batchableQueryCache.PutMany( keys, queryParameters, returnTypes, results, session)); } var puts = new bool[keys.Length]; for (var i = 0; i < keys.Length; i++) { puts[i] = queryCache.Put(keys[i], queryParameters[i], returnTypes[i], results[i], session); } return(puts); }
/// <summary> /// Attempt to cache objects, after loading them from the database. /// </summary> /// <param name="queryCache">The cache.</param> /// <param name="keys">The query keys.</param> /// <param name="queryParameters">The array of query parameters matching <paramref name="keys"/>.</param> /// <param name="returnTypes">The array of query result row types matching <paramref name="keys"/>.</param> /// <param name="results">The array of query results matching <paramref name="keys"/>.</param> /// <param name="session">The session for which the queries were executed.</param> /// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param> /// <returns>An array of boolean indicating if each query was successfully cached.</returns> /// <exception cref="CacheException"></exception> public static async Task <bool[]> PutManyAsync( this IQueryCache queryCache, QueryKey[] keys, QueryParameters[] queryParameters, ICacheAssembler[][] returnTypes, IList[] results, ISessionImplementor session, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (queryCache is IBatchableQueryCache batchableQueryCache) { return(await(batchableQueryCache.PutManyAsync( keys, queryParameters, returnTypes, results, session, cancellationToken)).ConfigureAwait(false)); } var puts = new bool[keys.Length]; for (var i = 0; i < keys.Length; i++) { puts[i] = await(queryCache.PutAsync(keys[i], queryParameters[i], returnTypes[i], results[i], session, cancellationToken)).ConfigureAwait(false); } return(puts); }
public void initTests() { if (testCache == null) { testCache = new QueryCache(); } }
public bool TryGetIfUseCache(string tableName, out IQueryCache cache) { if (IsUseCache) { if (!_caches.TryGetValue(tableName, out cache)) { lock (_lockGetCacheContainer) { if (!_caches.TryGetValue(tableName, out cache)) { cache = _queryCacheCreator.Create(tableName); if (cache == null) { throw new ArgumentException($"The type [{_queryCacheCreator.GetType().Name}] to create a {nameof(IQueryCacheCreator)} instance can not be null"); } _caches[tableName] = cache; } } } return(true); } else { cache = null; return(false); } }
private async Task <IList> ListUsingQueryCacheAsync(HashSet <string> querySpaces, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); IQueryCache queryCache = session.Factory.GetQueryCache(cacheRegion); ISet <FilterKey> filterKeys = FilterKey.CreateFilterKeys(session.EnabledFilters); List <IType[]> resultTypesList = new List <IType[]>(); int[] maxRows = new int[loaders.Count]; int[] firstRows = new int[loaders.Count]; for (int i = 0; i < loaders.Count; i++) { resultTypesList.Add(loaders[i].ResultTypes); firstRows[i] = parameters[i].RowSelection.FirstRow; maxRows[i] = parameters[i].RowSelection.MaxRows; } MultipleQueriesCacheAssembler assembler = new MultipleQueriesCacheAssembler(resultTypesList); QueryParameters combinedParameters = CreateCombinedQueryParameters(); QueryKey key = new QueryKey(session.Factory, SqlString, combinedParameters, filterKeys, null) .SetFirstRows(firstRows) .SetMaxRows(maxRows); IList result = await(assembler.GetResultFromQueryCacheAsync(session, combinedParameters, querySpaces, queryCache, key, cancellationToken)).ConfigureAwait(false); if (factory.Statistics.IsStatisticsEnabled) { if (result == null) { factory.StatisticsImplementor.QueryCacheMiss(key.ToString(), queryCache.RegionName); } else { factory.StatisticsImplementor.QueryCacheHit(key.ToString(), queryCache.RegionName); } } if (result == null) { log.Debug("Cache miss for multi criteria query"); IList list = await(DoListAsync(cancellationToken)).ConfigureAwait(false); result = list; if (session.CacheMode.HasFlag(CacheMode.Put)) { bool put = await(queryCache.PutAsync(key, new ICacheAssembler[] { assembler }, new object[] { list }, combinedParameters.NaturalKeyLookup, session, cancellationToken)).ConfigureAwait(false); if (put && factory.Statistics.IsStatisticsEnabled) { factory.StatisticsImplementor.QueryCachePut(key.ToString(), queryCache.RegionName); } } } return(GetResultList(result)); }
public async Task <T> ExecuteAsync(IQueryCache <T> cache) { if (enableCache_) { return(await cache.QueryAsync(query_)); } else { return(await cache.QueryIgnoreCacheAsync(query_)); } }
/// <summary> /// Get query results from the cache. /// </summary> /// <param name="queryCache">The cache.</param> /// <param name="key">The query key.</param> /// <param name="queryParameters">The query parameters.</param> /// <param name="returnTypes">The query result row types.</param> /// <param name="spaces">The query spaces.</param> /// <param name="session">The session for which the query is executed.</param> /// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param> /// <returns>The query results, if cached.</returns> public static async Task <IList> GetAsync( this IQueryCache queryCache, QueryKey key, QueryParameters queryParameters, ICacheAssembler[] returnTypes, ISet <string> spaces, ISessionImplementor session, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (queryCache is IBatchableQueryCache batchableQueryCache) { return(await(batchableQueryCache.GetAsync( key, queryParameters, returnTypes, spaces, session, cancellationToken)).ConfigureAwait(false)); } if (!_hasWarnForObsoleteQueryCache) { _hasWarnForObsoleteQueryCache = true; Log.Warn("{0} is obsolete, it should implement {1}", queryCache, nameof(IBatchableQueryCache)); } var persistenceContext = session.PersistenceContext; var defaultReadOnlyOrig = persistenceContext.DefaultReadOnly; if (queryParameters.IsReadOnlyInitialized) { persistenceContext.DefaultReadOnly = queryParameters.ReadOnly; } else { queryParameters.ReadOnly = persistenceContext.DefaultReadOnly; } try { #pragma warning disable 618 return(await(queryCache.GetAsync( #pragma warning restore 618 key, returnTypes, queryParameters.NaturalKeyLookup, spaces, session, cancellationToken)).ConfigureAwait(false)); } finally { persistenceContext.DefaultReadOnly = defaultReadOnlyOrig; } }
public Resolver(IDnsTransport transport, IQueryCache cache = null, IWhoisTransport wtransport = null, ITLDHandler tldHandler = null, ISpfChecker checker = null, int retrys = 3, int timeout = 60) { Transport = transport; SpfChecker = (checker ?? new SpfChecker()); Retries = retrys; TimeOut = timeout; UseRecursion = useRecursion; Cache = (cache ?? new QueryCache()); WhoisTransport = (wtransport ?? new WhoisTcpTransport()); TldHandler = (tldHandler ?? new TldHandler()); }
public IQueryCache GetQueryCache() { lock (lockobj) { if (_cache == null) { _cache = new StandardQueryCache(); } return(_cache); } }
/// <summary> /// Get query results from the cache. /// </summary> /// <param name="queryCache">The cache.</param> /// <param name="key">The query key.</param> /// <param name="queryParameters">The query parameters.</param> /// <param name="returnTypes">The query result row types.</param> /// <param name="spaces">The query spaces.</param> /// <param name="session">The session for which the query is executed.</param> /// <returns>The query results, if cached.</returns> public static IList Get( this IQueryCache queryCache, QueryKey key, QueryParameters queryParameters, ICacheAssembler[] returnTypes, ISet <string> spaces, ISessionImplementor session) { if (queryCache is IBatchableQueryCache batchableQueryCache) { return(batchableQueryCache.Get( key, queryParameters, returnTypes, spaces, session)); } if (!_hasWarnForObsoleteQueryCache) { _hasWarnForObsoleteQueryCache = true; Log.Warn("{0} is obsolete, it should implement {1}", queryCache, nameof(IBatchableQueryCache)); } var persistenceContext = session.PersistenceContext; var defaultReadOnlyOrig = persistenceContext.DefaultReadOnly; if (queryParameters.IsReadOnlyInitialized) { persistenceContext.DefaultReadOnly = queryParameters.ReadOnly; } else { queryParameters.ReadOnly = persistenceContext.DefaultReadOnly; } try { #pragma warning disable 618 return(queryCache.Get( #pragma warning restore 618 key, returnTypes, queryParameters.NaturalKeyLookup, spaces, session)); } finally { persistenceContext.DefaultReadOnly = defaultReadOnlyOrig; } }
public void ConverterQueryCacheTests() { IQueryCache cache = InstantiateCache(); IConverter cDown = new ConvertDown(); IConverter cUp = new ConvertUp(); IQueryCache convCache = ConverterCollections.GetQueryCache(cache, cUp, cDown, cUp, cDown); Assert.IsNotNull(convCache); for (int i = 0; i < 5; i++) { convCache.Add(i, i + 1); } Assert.AreEqual(convCache.Count, 5); IFilter filter = new EqualsFilter(IdentityExtractor.Instance, cDown.Convert("4")); object[] keys = convCache.GetKeys(filter); Assert.IsNotNull(keys); Assert.AreEqual(keys.Length, 1); Assert.AreEqual(keys[0], "3"); filter = new GreaterEqualsFilter(IdentityExtractor.Instance, "2"); object[] values = convCache.GetValues(filter); Assert.IsNotNull(values); Assert.AreEqual(values.Length, 4); values = convCache.GetValues(filter, Comparer.DefaultInvariant); Assert.IsNotNull(values); Assert.AreEqual(values.Length, 4); Assert.AreEqual(values[0], "2"); object[] entries = convCache.GetEntries(filter); Assert.IsNotNull(entries); Assert.AreEqual(entries.Length, 4); entries = convCache.GetEntries(filter, new KeyExtractor(IdentityExtractor.Instance)); Assert.IsNotNull(entries); Assert.AreEqual(entries.Length, 4); Assert.IsInstanceOf(typeof(ICacheEntry), entries[0]); ICacheEntry e = entries[0] as ICacheEntry; Assert.IsNotNull(e); Assert.AreEqual(e.Key, "1"); Assert.AreEqual(e.Value, "2"); Assert.IsInstanceOf(typeof(ConverterCollections.ConverterQueryCache), convCache); ConverterCollections.ConverterQueryCache cqc = convCache as ConverterCollections.ConverterQueryCache; Assert.IsNotNull(cqc); Assert.AreEqual(cqc.QueryCache, cache); }
public void EvictQueries(string cacheRegion) { if (cacheRegion == null) { throw new ArgumentNullException("cacheRegion", "use the zero-argument form to evict the default query cache"); } else if (queryCaches != null) { IQueryCache currentQueryCache = ( IQueryCache )queryCaches[cacheRegion]; if (currentQueryCache != null) { currentQueryCache.Clear(); } } }
public IList GetResultFromQueryCache(ISessionImplementor session, QueryParameters queryParameters, ISet <string> querySpaces, IQueryCache queryCache, QueryKey key) { if (!queryParameters.ForceCacheRefresh) { IList list = queryCache.Get(key, new ICacheAssembler[] { this }, queryParameters.NaturalKeyLookup, querySpaces, session); //we had to wrap the query results in another list in order to save all //the queries in the same bucket, now we need to do it the other way around. if (list != null) { list = (IList)list[0]; } return(list); } return(null); }
public IList GetResultFromQueryCache(ISessionImplementor session, QueryParameters queryParameters, ISet<string> querySpaces, IQueryCache queryCache, QueryKey key) { if (!queryParameters.ForceCacheRefresh) { IList list = queryCache.Get(key, new ICacheAssembler[] {this}, queryParameters.NaturalKeyLookup, querySpaces, session); //we had to wrap the query results in another list in order to save all //the queries in the same bucket, now we need to do it the other way around. if (list != null) { list = (IList) list[0]; } return list; } return null; }
private async Task <IList> ListUsingQueryCacheAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); IQueryCache queryCache = session.Factory.GetQueryCache(cacheRegion); ISet <FilterKey> filterKeys = FilterKey.CreateFilterKeys(session.EnabledFilters); ISet <string> querySpaces = new HashSet <string>(); List <IType[]> resultTypesList = new List <IType[]>(Translators.Count); for (int i = 0; i < Translators.Count; i++) { ITranslator queryTranslator = Translators[i]; querySpaces.UnionWith(queryTranslator.QuerySpaces); resultTypesList.Add(queryTranslator.ReturnTypes); } int[] firstRows = new int[Parameters.Count]; int[] maxRows = new int[Parameters.Count]; for (int i = 0; i < Parameters.Count; i++) { RowSelection rowSelection = Parameters[i].RowSelection; firstRows[i] = rowSelection.FirstRow; maxRows[i] = rowSelection.MaxRows; } MultipleQueriesCacheAssembler assembler = new MultipleQueriesCacheAssembler(resultTypesList); QueryKey key = new QueryKey(session.Factory, SqlString, combinedParameters, filterKeys, null) .SetFirstRows(firstRows) .SetMaxRows(maxRows); IList result = await(assembler.GetResultFromQueryCacheAsync(session, combinedParameters, querySpaces, queryCache, key, cancellationToken)).ConfigureAwait(false); if (result == null) { log.Debug("Cache miss for multi query"); var list = await(DoListAsync(cancellationToken)).ConfigureAwait(false); await(queryCache.PutAsync(key, new ICacheAssembler[] { assembler }, new object[] { list }, false, session, cancellationToken)).ConfigureAwait(false); result = list; } return(GetResultList(result)); }
private IList ListUsingQueryCache() { IQueryCache queryCache = session.Factory.GetQueryCache(cacheRegion); ISet <FilterKey> filterKeys = FilterKey.CreateFilterKeys(session.EnabledFilters, session.EntityMode); ISet <string> querySpaces = new HashedSet <string>(); List <IType[]> resultTypesList = new List <IType[]>(Translators.Count); for (int i = 0; i < Translators.Count; i++) { ITranslator queryTranslator = Translators[i]; querySpaces.AddAll(queryTranslator.QuerySpaces); resultTypesList.Add(queryTranslator.ReturnTypes); } int[] firstRows = new int[Parameters.Count]; int[] maxRows = new int[Parameters.Count]; for (int i = 0; i < Parameters.Count; i++) { RowSelection rowSelection = Parameters[i].RowSelection; firstRows[i] = rowSelection.FirstRow; maxRows[i] = rowSelection.MaxRows; } MultipleQueriesCacheAssembler assembler = new MultipleQueriesCacheAssembler(resultTypesList); QueryKey key = new QueryKey(session.Factory, SqlString, combinedParameters, filterKeys) .SetFirstRows(firstRows) .SetMaxRows(maxRows); IList result = assembler.GetResultFromQueryCache(session, combinedParameters, querySpaces, queryCache, key); if (result == null) { log.Debug("Cache miss for multi query"); var list = DoList(); queryCache.Put(key, new ICacheAssembler[] { assembler }, new object[] { list }, false, session); result = list; } return(GetResultList(result)); }
private IList ListUsingQueryCache() { IQueryCache queryCache = session.Factory.GetQueryCache(cacheRegion); ISet <FilterKey> filterKeys = FilterKey.CreateFilterKeys(session.EnabledFilters, session.EntityMode); ISet <string> querySpaces = new HashSet <string>(); List <IType[]> resultTypesList = new List <IType[]>(); int[] maxRows = new int[loaders.Count]; int[] firstRows = new int[loaders.Count]; for (int i = 0; i < loaders.Count; i++) { querySpaces.UnionWith(loaders[i].QuerySpaces); resultTypesList.Add(loaders[i].ResultTypes); firstRows[i] = parameters[i].RowSelection.FirstRow; maxRows[i] = parameters[i].RowSelection.MaxRows; } MultipleQueriesCacheAssembler assembler = new MultipleQueriesCacheAssembler(resultTypesList); QueryParameters combinedParameters = CreateCombinedQueryParameters(); QueryKey key = new QueryKey(session.Factory, SqlString, combinedParameters, filterKeys, null) .SetFirstRows(firstRows) .SetMaxRows(maxRows); IList result = assembler.GetResultFromQueryCache(session, combinedParameters, querySpaces, queryCache, key); if (result == null) { log.Debug("Cache miss for multi criteria query"); IList list = DoList(); queryCache.Put(key, new ICacheAssembler[] { assembler }, new object[] { list }, combinedParameters.NaturalKeyLookup, session); result = list; } return(GetResultList(result)); }
public IQueryCache GetQueryCache(string cacheRegion) { if (cacheRegion == null) { return(QueryCache); } if (!settings.IsQueryCacheEnabled) { return(null); } return(queryCaches.GetOrAdd( cacheRegion, cr => { IQueryCache currentQueryCache = settings.QueryCacheFactory.GetQueryCache(cacheRegion, updateTimestampsCache, settings, properties); allCacheRegions[currentQueryCache.RegionName] = currentQueryCache.Cache; return currentQueryCache; })); }
public IQueryCache GetQueryCache(string cacheRegion) { if (cacheRegion == null) { return(QueryCache); } IQueryCache currentQueryCache = ( IQueryCache )queryCaches[cacheRegion]; if (currentQueryCache == null) { currentQueryCache = settings.QueryCacheFactory.GetQueryCache( cacheRegion, settings.CacheProvider, updateTimestampsCache, properties ); queryCaches[cacheRegion] = currentQueryCache; } return(currentQueryCache); }
protected Layer(String layerName, IStyle style, IProvider dataSource, IGeometryFactory geometryFactory, ILayer parent) : base(parent) { if (layerName == null) { throw new ArgumentNullException("layerName"); } if (dataSource == null) { throw new ArgumentNullException("dataSource"); } _layerName = layerName; _parent = parent; if (parent != null) { _asyncQuery = parent.AsyncQuery; _geoFactory = geometryFactory; dataSource = parent.DataSource as IAsyncProvider ?? CreateAsyncProvider(parent.DataSource); CoordinateTransformation = parent.CoordinateTransformation; _loadedRegion = parent.LoadedRegion; style = parent.Style; } IAsyncProvider asyncProvider = dataSource as IAsyncProvider; _dataSource = asyncProvider ?? CreateAsyncProvider(dataSource); _style = style; // TODO: inject the cache type or instance... _cache = new NullQueryCache(); }
/// <summary> /// Put query results in the cache. /// </summary> /// <param name="queryCache">The cache.</param> /// <param name="key">The query key.</param> /// <param name="queryParameters">The query parameters.</param> /// <param name="returnTypes">The query result row types.</param> /// <param name="result">The query result.</param> /// <param name="session">The session for which the query was executed.</param> /// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param> /// <returns><see langword="true" /> if the result has been cached, <see langword="false" /> /// otherwise.</returns> public static Task <bool> PutAsync( this IQueryCache queryCache, QueryKey key, QueryParameters queryParameters, ICacheAssembler[] returnTypes, IList result, ISessionImplementor session, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(Task.FromCanceled <bool>(cancellationToken)); } try { if (queryCache is IBatchableQueryCache batchableQueryCache) { return(batchableQueryCache.PutAsync( key, queryParameters, returnTypes, result, session, cancellationToken)); } #pragma warning disable 618 return(queryCache.PutAsync( #pragma warning restore 618 key, returnTypes, result, queryParameters.NaturalKeyLookup, session, cancellationToken)); } catch (Exception ex) { return(Task.FromException <bool>(ex)); } }
public AddAsyncQueryExecutor(IQueryCache <AddQuery, AsyncLazy <int> > cache, TimeSpan delayTime) : base(cache) { m_delayTime = delayTime; }
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 RequestHandler(IRepository repository, IQueryCache cache) { _repository = repository; _cache = cache; }
public QueryRunner(IDependencyResolver resolver, IQueryCache queryCache) { _resolver = resolver; _queryCache = queryCache; }
public async Task <IList> GetResultFromQueryCacheAsync(ISessionImplementor session, QueryParameters queryParameters, ISet <string> querySpaces, IQueryCache queryCache, QueryKey key, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!queryParameters.ForceCacheRefresh) { IList list = await(queryCache.GetAsync(key, new ICacheAssembler[] { this }, queryParameters.NaturalKeyLookup, querySpaces, session, cancellationToken)).ConfigureAwait(false); //we had to wrap the query results in another list in order to save all //the queries in the same bucket, now we need to do it the other way around. if (list != null) { list = (IList)list[0]; } return(list); } return(null); }
/// <summary> /// Constructs an AggregateQueryClientSideExecutor /// </summary> /// <param name="childAsyncQueryExecutor">query executor to execute child queries</param> /// <param name="queryCache">The query cache to be used</param> public AggregateAsyncQueryClientSideExecutor(AsyncQueryExecutor <TQuery, TResult> childAsyncQueryExecutor, IQueryCache <AggregateQuery, AsyncLazy <List <TResult> > > queryCache) : base(queryCache) { _mChildAsyncQueryExecutor = childAsyncQueryExecutor; }
private IList GetResultFromQueryCache(ISessionImplementor session, QueryParameters queryParameters, ISet<string> querySpaces, IType[] resultTypes, IQueryCache queryCache, QueryKey key) { IList result = null; if ((!queryParameters.ForceCacheRefresh) && (session.CacheMode & CacheMode.Get) == CacheMode.Get) { IPersistenceContext persistenceContext = session.PersistenceContext; bool defaultReadOnlyOrig = persistenceContext.DefaultReadOnly; if (queryParameters.IsReadOnlyInitialized) persistenceContext.DefaultReadOnly = queryParameters.ReadOnly; else queryParameters.ReadOnly = persistenceContext.DefaultReadOnly; try { result = queryCache.Get(key, resultTypes, queryParameters.NaturalKeyLookup, querySpaces, session); if (_factory.Statistics.IsStatisticsEnabled) { if (result == null) { _factory.StatisticsImplementor.QueryCacheMiss(QueryIdentifier, queryCache.RegionName); } else { _factory.StatisticsImplementor.QueryCacheHit(QueryIdentifier, queryCache.RegionName); } } } finally { persistenceContext.DefaultReadOnly = defaultReadOnlyOrig; } } return result; }
protected WebApiQueryExecutorBase(WebApiClient webApiClient, IQueryCache <TQuery, AsyncLazy <TResult> > queryCache, string apiPath) : base(queryCache) { m_webApiClient = webApiClient; m_apiPath = apiPath; }
/// <summary> /// Protected constructor of the query executor /// </summary> /// <param name="queryCache"></param> protected SyncQueryExecutor(IQueryCache <TQuery, Lazy <TResult> > queryCache) { m_queryTaskCache = queryCache; }
private IList GetResultFromQueryCache(ISessionImplementor session, QueryParameters queryParameters, ISet<string> querySpaces, IType[] resultTypes, IQueryCache queryCache, QueryKey key) { IList result = null; if ((!queryParameters.ForceCacheRefresh) && (session.CacheMode & CacheMode.Get) == CacheMode.Get) { result = queryCache.Get(key, resultTypes, queryParameters.NaturalKeyLookup, querySpaces, session); if (factory.Statistics.IsStatisticsEnabled) { if (result == null) { factory.StatisticsImplementor.QueryCacheMiss(QueryIdentifier, queryCache.RegionName); } else { factory.StatisticsImplementor.QueryCacheHit(QueryIdentifier, queryCache.RegionName); } } } return result; }
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, IMapping mapping, Settings settings, EventListeners listeners) { Init(); log.Info("building session factory"); properties = cfg.Properties; interceptor = cfg.Interceptor; this.settings = settings; sqlFunctionRegistry = new SQLFunctionRegistry(settings.Dialect, cfg.SqlFunctions); eventListeners = listeners; if (log.IsDebugEnabled) { log.Debug("instantiating session factory with properties: " + CollectionPrinter.ToString(properties)); } settings.CacheProvider.Start(properties); // Generators: identifierGenerators = new Hashtable(); foreach (PersistentClass model in cfg.ClassMappings) { if (!model.IsInherited) { IIdentifierGenerator generator = model.Identifier.CreateIdentifierGenerator(settings.Dialect, settings.DefaultCatalogName, settings.DefaultSchemaName, (RootClass) model); identifierGenerators[model.MappedClass] = generator; } } // Persisters: IDictionary caches = new Hashtable(); classPersisters = new Hashtable(); classPersistersByName = new Hashtable(); IDictionary classMeta = new Hashtable(); foreach (PersistentClass model in cfg.ClassMappings) { string cacheRegion = model.RootClazz.CacheRegionName; ICacheConcurrencyStrategy cache = (ICacheConcurrencyStrategy) caches[cacheRegion]; if (cache == null) { cache = CacheFactory.CreateCache(model.CacheConcurrencyStrategy, cacheRegion, model.IsMutable, settings, properties); if (cache != null) { caches.Add(cacheRegion, cache); allCacheRegions.Add(cache.RegionName, cache.Cache); } } IEntityPersister cp = PersisterFactory.CreateClassPersister(model, cache, this, mapping); classPersisters[model.MappedClass] = cp; // Adds the "Namespace.ClassName" (FullClassname) as a lookup to get to the Persiter. // Most of the internals of NHibernate use this method to get to the Persister since // Model.Name is used in so many places. It would be nice to fix it up to be Model.TypeName // instead of just FullClassname classPersistersByName[model.EntityName] = cp; // Add in the AssemblyQualifiedName (includes version) as a lookup to get to the Persister. // In HQL the Imports are used to get from the Classname to the Persister. The // Imports provide the ability to jump from the Classname to the AssemblyQualifiedName. classPersistersByName[model.MappedClass.AssemblyQualifiedName] = cp; classMeta[model.MappedClass] = cp.ClassMetadata; } classMetadata = new Hashtable(classMeta); IDictionary tmpEntityToCollectionRoleMap= new Hashtable(); collectionPersisters = new Hashtable(); foreach (Mapping.Collection map in cfg.CollectionMappings) { ICacheConcurrencyStrategy cache = CacheFactory.CreateCache(map.CacheConcurrencyStrategy, map.CacheRegionName, map.Owner.IsMutable, settings, properties); if (cache != null) allCacheRegions[cache.RegionName] = cache.Cache; collectionPersisters[map.Role] = PersisterFactory.CreateCollectionPersister(cfg, map, cache, this).CollectionMetadata; ICollectionPersister persister = collectionPersisters[map.Role] as ICollectionPersister; IType indexType = persister.IndexType; if (indexType != null && indexType.IsAssociationType && !indexType.IsAnyType) { string entityName = ((IAssociationType)indexType).GetAssociatedEntityName(this); ISet roles = tmpEntityToCollectionRoleMap[entityName] as ISet; if (roles == null) { roles = new HashedSet(); tmpEntityToCollectionRoleMap[entityName] = roles; } roles.Add(persister.Role); } IType elementType = persister.ElementType; if (elementType.IsAssociationType && !elementType.IsAnyType) { string entityName = ((IAssociationType)elementType).GetAssociatedEntityName(this); ISet roles = tmpEntityToCollectionRoleMap[entityName] as ISet; if (roles == null) { roles = new HashedSet(); tmpEntityToCollectionRoleMap[entityName] = roles; } roles.Add(persister.Role); } } collectionMetadata = new Hashtable(collectionPersisters); collectionRolesByEntityParticipant = new Hashtable(tmpEntityToCollectionRoleMap); //TODO: // For databinding: //templates = XMLDatabinder.GetOutputStyleSheetTemplates( properties ); // serialization info name = settings.SessionFactoryName; try { uuid = (string) UuidGenerator.Generate(null, null); } catch (Exception) { throw new AssertionFailure("could not generate UUID"); } SessionFactoryObjectFactory.AddInstance(uuid, name, this, properties); // Named queries: // TODO: precompile and cache named queries namedQueries = new Dictionary<string, NamedQueryDefinition>(cfg.NamedQueries); namedSqlQueries = new Dictionary<string, NamedSQLQueryDefinition>(cfg.NamedSQLQueries); sqlResultSetMappings = new Dictionary<string, ResultSetMappingDefinition>(cfg.SqlResultSetMappings); filters = new Dictionary<string, FilterDefinition>(cfg.FilterDefinitions); imports = new Dictionary<string, string>(cfg.Imports); // after *all* persisters and named queries are registered foreach (IEntityPersister persister in classPersisters.Values) { persister.PostInstantiate(); } foreach (ICollectionPersister persister in collectionPersisters.Values) { persister.PostInstantiate(); } log.Debug("Instantiated session factory"); if (settings.IsAutoCreateSchema) { new SchemaExport(cfg).Create(false, true); } /* if ( settings.IsAutoUpdateSchema ) { new SchemaUpdate( cfg ).Execute( false, true ); } */ if (settings.IsAutoDropSchema) { schemaExport = new SchemaExport(cfg); } // Obtaining TransactionManager - not ported from H2.1 currentSessionContext = BuildCurrentSessionContext(); if (settings.IsQueryCacheEnabled) { updateTimestampsCache = new UpdateTimestampsCache(settings, properties); queryCache = settings.QueryCacheFactory .GetQueryCache(null, updateTimestampsCache, settings, properties); queryCaches = Hashtable.Synchronized(new Hashtable()); } else { updateTimestampsCache = null; queryCache = null; queryCaches = null; } //checking for named queries if (settings.IsNamedQueryStartupCheckingEnabled) { IDictionary<string, HibernateException> errors = CheckNamedQueries(); if (errors.Count > 0) { StringBuilder failingQueries = new StringBuilder("Errors in named queries: "); foreach (KeyValuePair<string, HibernateException> pair in errors) { failingQueries.Append('{').Append(pair.Key).Append('}'); log.Error("Error in named query: " + pair.Key, pair.Value); } throw new HibernateException(failingQueries.ToString()); } } Statistics.IsStatisticsEnabled = settings.IsStatisticsEnabled; // EntityNotFoundDelegate IEntityNotFoundDelegate enfd = cfg.EntityNotFoundDelegate; if (enfd == null) { enfd = new DefaultEntityNotFoundDelegate(); } entityNotFoundDelegate = enfd; }
public 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; }
private static IList GetResultFromQueryCache(ISessionImplementor session, QueryParameters queryParameters, ISet querySpaces, IType[] resultTypes, IQueryCache queryCache, QueryKey key) { if (!queryParameters.ForceCacheRefresh) { return queryCache.Get(key, resultTypes, querySpaces, session); } return null; }
private void PutResultInQueryCache(ISessionImplementor session, QueryParameters queryParameters, IType[] resultTypes, IQueryCache queryCache, QueryKey key, IList result) { if ((session.CacheMode & CacheMode.Put) == CacheMode.Put) { bool put = queryCache.Put(key, resultTypes, result, queryParameters.NaturalKeyLookup, session); if (put && factory.Statistics.IsStatisticsEnabled) { factory.StatisticsImplementor.QueryCachePut(QueryIdentifier, queryCache.RegionName); } } }
/// <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; } }