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