fixup! Implement multiple get and put for query cache and query batch

Adjust code according to review

Author: fredericDelaporte

src/NHibernate/Async/Multi/QueryBatch.cs

@@ -150,7 +150,8 @@ protected async Task ExecuteBatchedAsync(CancellationToken cancellationToken)
 					}
 				}
 
-				// Query cacheable results must be put in cache before being transformed by ProcessResults.
+				// Query cacheable results must be cached untransformed: the put does not need to wait for
+				// the ProcessResults.
 				await (PutCacheableResultsAsync(cancellationToken)).ConfigureAwait(false);
 
 				foreach (var multiSource in _queries)
@@ -228,11 +229,8 @@ private async Task GetCachedResultsAsync(CancellationToken cancellationToken)
 		private async Task PutCacheableResultsAsync(CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
-			if (!Session.CacheMode.HasFlag(CacheMode.Put))
-				return;
-
 			var statisticsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
-			var queriesByCaches = GetQueriesByCaches(ci => ci.IsCacheable && !ci.IsResultFromCache);
+			var queriesByCaches = GetQueriesByCaches(ci => ci.ResultToCache != null);
 			foreach (var queriesByCache in queriesByCaches)
 			{
 				var queryInfos = queriesByCache.ToArray();
@@ -247,7 +245,7 @@ private async Task PutCacheableResultsAsync(CancellationToken cancellationToken)
 					keys[i] = queryInfo.CacheKey;
 					parameters[i] = queryInfo.Parameters;
 					returnTypes[i] = queryInfo.CacheKey.ResultTransformer.GetCachedResultTypes(queryInfo.ResultTypes);
-					results[i] = queryInfo.Result;
+					results[i] = queryInfo.ResultToCache;
 				}
 
 				var putted = await (cache.PutManyAsync(keys, parameters, returnTypes, results, Session, cancellationToken)).ConfigureAwait(false);

src/NHibernate/Async/Multi/QueryBatchItemBase.cs

@@ -100,6 +100,8 @@ public async Task<int> ProcessResultsSetAsync(DbDataReader reader, CancellationT
 				}
 
 				queryInfo.Result = tmpResults;
+				if (queryInfo.CanPutToCache)
+					queryInfo.ResultToCache = tmpResults;
 
 				await (reader.NextResultAsync(cancellationToken)).ConfigureAwait(false);
 			}

src/NHibernate/Multi/ICachingInformation.cs

@@ -12,14 +12,19 @@ namespace NHibernate.Multi
 	public interface ICachingInformation
 	{
 		/// <summary>
-		/// The query parameters.
+		/// Is the query cacheable?
 		/// </summary>
-		QueryParameters Parameters { get; }
+		bool IsCacheable { get; }
 
 		/// <summary>
-		/// The query result.
+		/// The query cache key.
 		/// </summary>
-		IList Result { get; }
+		QueryKey CacheKey { get; }
+
+		/// <summary>
+		/// The query parameters.
+		/// </summary>
+		QueryParameters Parameters { get; }
 
 		/// <summary>
 		/// The query spaces.
@@ -31,18 +36,13 @@ public interface ICachingInformation
 		/// </remarks>
 		ISet<string> QuerySpaces { get; }
 
-		/// <summary>
-		/// Is the query cacheable?
-		/// </summary>
-		bool IsCacheable { get; }
-
 		/// <summary>
 		/// Can the query be obtained from cache?
 		/// </summary>
 		bool CanGetFromCache { get; }
 
 		/// <summary>
-		/// Indicates if <see cref="Result"/> was obtained from the cache.
+		/// Indicates if the query result was obtained from the cache.
 		/// </summary>
 		bool IsResultFromCache { get; }
 
@@ -52,14 +52,14 @@ public interface ICachingInformation
 		IType[] ResultTypes { get; }
 
 		/// <summary>
-		/// The query identifier, for statistics purpose.
+		/// The query result to put in the cache. <see langword="null" /> if no put should be done.
 		/// </summary>
-		string QueryIdentifier { get; }
+		IList ResultToCache { get; }
 
 		/// <summary>
-		/// The query cache key.
+		/// The query identifier, for statistics purpose.
 		/// </summary>
-		QueryKey CacheKey { get; }
+		string QueryIdentifier { get; }
 
 		/// <summary>
 		/// Set the result retrieved from the cache.

src/NHibernate/Multi/QueryBatch.cs

@@ -176,7 +176,8 @@ protected void ExecuteBatched()
 					}
 				}
 
-				// Query cacheable results must be put in cache before being transformed by ProcessResults.
+				// Query cacheable results must be cached untransformed: the put does not need to wait for
+				// the ProcessResults.
 				PutCacheableResults();
 
 				foreach (var multiSource in _queries)
@@ -260,11 +261,8 @@ private void CombineQueries(IResultSetsCommand resultSetsCommand)
 
 		private void PutCacheableResults()
 		{
-			if (!Session.CacheMode.HasFlag(CacheMode.Put))
-				return;
-
 			var statisticsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
-			var queriesByCaches = GetQueriesByCaches(ci => ci.IsCacheable && !ci.IsResultFromCache);
+			var queriesByCaches = GetQueriesByCaches(ci => ci.ResultToCache != null);
 			foreach (var queriesByCache in queriesByCaches)
 			{
 				var queryInfos = queriesByCache.ToArray();
@@ -279,7 +277,7 @@ private void PutCacheableResults()
 					keys[i] = queryInfo.CacheKey;
 					parameters[i] = queryInfo.Parameters;
 					returnTypes[i] = queryInfo.CacheKey.ResultTransformer.GetCachedResultTypes(queryInfo.ResultTypes);
-					results[i] = queryInfo.Result;
+					results[i] = queryInfo.ResultToCache;
 				}
 
 				var putted = cache.PutMany(keys, parameters, returnTypes, results, Session);

src/NHibernate/Multi/QueryBatchItemBase.cs

@@ -27,28 +27,48 @@ protected class QueryInfo : ICachingInformation
 			/// The query loader.
 			/// </summary>
 			public Loader.Loader Loader { get; set; }
+
+			/// <summary>
+			/// The query result.
+			/// </summary>
+			public IList Result { get; set; }
+
 			/// <inheritdoc />
 			public QueryParameters Parameters { get; }
-			/// <inheritdoc />
-			public IList Result { get; set; }
+
 			/// <inheritdoc />
 			public ISet<string> QuerySpaces { get; }
 
 			//Cache related properties:
+
 			/// <inheritdoc />
 			public bool IsCacheable { get; }
+
 			/// <inheritdoc />
 			public QueryKey CacheKey { get;}
+
 			/// <inheritdoc />
 			public bool CanGetFromCache { get; }
+
 			// Do not store but forward instead: Loader.ResultTypes can be null initially (if AutoDiscoverTypes
 			// is enabled).
 			/// <inheritdoc />
 			public IType[] ResultTypes => Loader.ResultTypes;
+
 			/// <inheritdoc />
 			public string QueryIdentifier => Loader.QueryIdentifier;
+
 			/// <inheritdoc />
 			public bool IsResultFromCache { get; private set; }
+
+			/// <inheritdoc />
+			public IList ResultToCache { get; set; }
+
+			/// <summary>
+			/// Should a result retrieved from database be cached?
+			/// </summary>
+			public bool CanPutToCache { get; }
+
 			/// <summary>
 			/// The cache batcher to use for entities and collections puts.
 			/// </summary>
@@ -75,6 +95,7 @@ public QueryInfo(
 
 				CacheKey = Loader.GenerateQueryKey(session, Parameters);
 				CanGetFromCache = Loader.CanGetFromCache(session, Parameters);
+				CanPutToCache = session.CacheMode.HasFlag(CacheMode.Put);
 			}
 
 			/// <inheritdoc />
@@ -213,6 +234,8 @@ public int ProcessResultsSet(DbDataReader reader)
 				}
 
 				queryInfo.Result = tmpResults;
+				if (queryInfo.CanPutToCache)
+					queryInfo.ResultToCache = tmpResults;
 
 				reader.NextResult();
 			}
@@ -237,8 +260,7 @@ public void ProcessResults()
 
 				if (queryInfo.IsCacheable)
 				{
-					// This transformation must be done after result has been put in cache (if it was
-					// to be put). So the batcher must handle cache puts before calling ProcessResults.
+					// This transformation must not be applied to ResultToCache.
 					queryInfo.Result =
 						queryInfo.Loader.TransformCacheableResults(
 							queryInfo.Parameters, queryInfo.CacheKey.ResultTransformer, queryInfo.Result);
@@ -261,7 +283,7 @@ protected List<T> GetTypedResults<T>()
 			ThrowIfNotInitialized();
 			if (_queryInfos.Any(qi => qi.Result == null))
 			{
-				throw new InvalidOperationException("Batch is not executed yet. You must call IQueryBatch.Execute() before accessing results.");
+				throw new InvalidOperationException("Some query results are missing, batch is likely not fully executed yet.");
 			}
 			var results = new List<T>(_queryInfos.Sum(qi => qi.Result.Count));
 			foreach (var queryInfo in _queryInfos)
@@ -302,7 +324,11 @@ private void InitializeEntitiesAndCollections(DbDataReader reader, List<object>[
 		private void ThrowIfNotInitialized()
 		{
 			if (_queryInfos == null)
-				throw new InvalidOperationException("The query item has not been initialized.");
+				throw new InvalidOperationException(
+					"The query item has not been initialized. A query item must belong to a batch " +
+					$"({nameof(IQueryBatch)}) and the batch must be executed ({nameof(IQueryBatch)}." +
+					$"{nameof(IQueryBatch.Execute)} or {nameof(IQueryBatch)}.{nameof(IQueryBatch.GetResult)}) " +
+					"before retrieving the item result.");
 		}
 	}
 }