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