Fix future queries with non lazy associations

src/AsyncGenerator.yml

@@ -5,6 +5,10 @@
   applyChanges: true
   analyzation:
     methodConversion:
+#TODO 6.0: Remove ignore rule for IQueryBatchItem.ProcessResults  
+    - conversion: Ignore
+      name: ProcessResults
+      containingTypeName: IQueryBatchItem
     - conversion: Ignore
       name: PostProcessInsert
       containingTypeName: HqlSqlWalker

src/NHibernate.Test/Async/Futures/QueryBatchFixture.cs

@@ -498,6 +498,35 @@ public async Task CacheModeWorksWithFutureAsync()
 			}
 		}
 
+		//GH-2173
+		[Test]
+		public async Task CanFetchNonLazyEntitiesInSubsequentQueryAsync()
+		{
+			Sfi.Statistics.IsStatisticsEnabled = true;
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				await (s.SaveAsync(
+					new EntityEager
+					{
+						Name = "EagerManyToOneAssociation",
+						EagerEntity = new EntityEagerChild {Name = "association"}
+					}));
+				await (t.CommitAsync());
+			}
+
+			using (var s = OpenSession())
+			{
+				Sfi.Statistics.Clear();
+				//EntityEager.EagerEntity is lazy initialized instead of being loaded by the second query 
+				s.QueryOver<EntityEager>().Fetch(SelectMode.Skip, x => x.EagerEntity).Future();
+				await (s.QueryOver<EntityEager>().Fetch(SelectMode.Fetch, x => x.EagerEntity).Future().GetEnumerableAsync());
+
+				if(SupportsMultipleQueries)
+					Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
+			}
+		}
+
 		#region Test Setup
 
 		protected override HbmMapping GetMappings()
@@ -543,6 +572,10 @@ protected override HbmMapping GetMappings()
 					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
 					rc.Property(x => x.Name);
 
+					rc.ManyToOne(x => x.EagerEntity, m =>
+					{
+						m.Cascade(Mapping.ByCode.Cascade.Persist);
+					});
 					rc.Bag(ep => ep.ChildrenListSubselect,
 							m =>
 							{
@@ -560,6 +593,14 @@ protected override HbmMapping GetMappings()
 							},
 							a => a.OneToMany());
 				});
+			mapper.Class<EntityEagerChild>(
+				rc =>
+				{
+					rc.Lazy(false);
+
+					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
+					rc.Property(x => x.Name);
+				});
 			mapper.Class<EntitySubselectChild>(
 				rc =>
 				{

src/NHibernate.Test/Futures/Entities.cs

@@ -36,11 +36,18 @@ public class EntitySubselectChild
 		public virtual EntityEager Parent { get; set; }
 	}
 
+	public class EntityEagerChild
+	{
+		public Guid Id { get; set; }
+		public string Name { get; set; }
+	}
+
 	public class EntityEager
 	{
 		public Guid Id { get; set; }
 		public string Name { get; set; }
 
+		public EntityEagerChild EagerEntity { get; set; }
 		public IList<EntitySubselectChild> ChildrenListSubselect { get; set; }
 		public IList<EntitySimpleChild> ChildrenListEager { get; set; } //= new HashSet<EntitySimpleChild>();
 	}

src/NHibernate.Test/Futures/QueryBatchFixture.cs

@@ -486,6 +486,35 @@ public void CacheModeWorksWithFuture()
 			}
 		}
 
+		//GH-2173
+		[Test]
+		public void CanFetchNonLazyEntitiesInSubsequentQuery()
+		{
+			Sfi.Statistics.IsStatisticsEnabled = true;
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				s.Save(
+					new EntityEager
+					{
+						Name = "EagerManyToOneAssociation",
+						EagerEntity = new EntityEagerChild {Name = "association"}
+					});
+				t.Commit();
+			}
+
+			using (var s = OpenSession())
+			{
+				Sfi.Statistics.Clear();
+				//EntityEager.EagerEntity is lazy initialized instead of being loaded by the second query 
+				s.QueryOver<EntityEager>().Fetch(SelectMode.Skip, x => x.EagerEntity).Future();
+				s.QueryOver<EntityEager>().Fetch(SelectMode.Fetch, x => x.EagerEntity).Future().GetEnumerable();
+
+				if(SupportsMultipleQueries)
+					Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
+			}
+		}
+
 		#region Test Setup
 
 		protected override HbmMapping GetMappings()
@@ -531,6 +560,10 @@ protected override HbmMapping GetMappings()
 					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
 					rc.Property(x => x.Name);
 
+					rc.ManyToOne(x => x.EagerEntity, m =>
+					{
+						m.Cascade(Mapping.ByCode.Cascade.Persist);
+					});
 					rc.Bag(ep => ep.ChildrenListSubselect,
 							m =>
 							{
@@ -548,6 +581,14 @@ protected override HbmMapping GetMappings()
 							},
 							a => a.OneToMany());
 				});
+			mapper.Class<EntityEagerChild>(
+				rc =>
+				{
+					rc.Lazy(false);
+
+					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
+					rc.Property(x => x.Name);
+				});
 			mapper.Class<EntitySubselectChild>(
 				rc =>
 				{

src/NHibernate/Async/Multi/IQueryBatchItem.cs

@@ -36,4 +36,9 @@ public partial interface IQueryBatchItem
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
 		Task ExecuteNonBatchedAsync(CancellationToken cancellationToken);
 	}
+
+	internal partial interface IQueryBatchItemWithAsyncProcessResults
+	{
+		Task ProcessResultsAsync(CancellationToken cancellationToken);
+	}
 }

src/NHibernate/Async/Multi/QueryBatch.cs

@@ -127,37 +127,48 @@ protected async Task ExecuteBatchedAsync(CancellationToken cancellationToken)
 			}
 
 			var rowCount = 0;
+			CacheBatcher cacheBatcher = null;
 			try
 			{
 				if (resultSetsCommand.HasQueries)
 				{
+					cacheBatcher = new CacheBatcher(Session);
 					using (var reader = await (resultSetsCommand.GetReaderAsync(Timeout, cancellationToken)).ConfigureAwait(false))
 					{
-						var cacheBatcher = new CacheBatcher(Session);
 						foreach (var query in _queries)
 						{
 							if (query.CachingInformation != null)
 							{
-								foreach (var cachingInfo in query.CachingInformation.Where(ci => ci.IsCacheable))
+								foreach (var cachingInfo in query.CachingInformation)
 								{
 									cachingInfo.SetCacheBatcher(cacheBatcher);
 								}
 							}
 
 							rowCount += await (query.ProcessResultsSetAsync(reader, cancellationToken)).ConfigureAwait(false);
 						}
-						await (cacheBatcher.ExecuteBatchAsync(cancellationToken)).ConfigureAwait(false);
 					}
 				}
 
-				// Query cacheable results must be cached untransformed: the put does not need to wait for
-				// the ProcessResults.
-				await (PutCacheableResultsAsync(cancellationToken)).ConfigureAwait(false);
-
 				foreach (var query in _queries)
 				{
-					query.ProcessResults();
+					//TODO 6.0: Replace with query.ProcessResults();
+					if (query is IQueryBatchItemWithAsyncProcessResults q)
+						await (q.ProcessResultsAsync(cancellationToken)).ConfigureAwait(false);
+					else
+						query.ProcessResults();
 				}
+
+				var executeBatchTask = cacheBatcher?.ExecuteBatchAsync(cancellationToken);
+
+				if (executeBatchTask != null)
+
+				{
+
+					await (executeBatchTask).ConfigureAwait(false);
+
+				}
+				await (PutCacheableResultsAsync(cancellationToken)).ConfigureAwait(false);
 			}
 			catch (OperationCanceledException) { throw; }
 			catch (Exception sqle)

src/NHibernate/Async/Multi/QueryBatchItemBase.cs

@@ -23,7 +23,7 @@ namespace NHibernate.Multi
 {
 	using System.Threading.Tasks;
 	using System.Threading;
-	public abstract partial class QueryBatchItemBase<TResult> : IQueryBatchItem<TResult>
+	public abstract partial class QueryBatchItemBase<TResult> : IQueryBatchItem<TResult>, IQueryBatchItemWithAsyncProcessResults
 	{
 
 		/// <inheritdoc />
@@ -103,17 +103,46 @@ public async Task<int> ProcessResultsSetAsync(DbDataReader reader, CancellationT
 
 					queryInfo.Result = tmpResults;
 					if (queryInfo.CanPutToCache)
-						queryInfo.ResultToCache = tmpResults;
+						queryInfo.ResultToCache = new List<object>(tmpResults);
 
 					await (reader.NextResultAsync(cancellationToken)).ConfigureAwait(false);
 				}
 
-				await (InitializeEntitiesAndCollectionsAsync(reader, hydratedObjects, cancellationToken)).ConfigureAwait(false);
-
+				StopLoadingCollections(reader);
+				_reader = reader;
+				_hydratedObjects = hydratedObjects;
 				return rowCount;
 			}
 		}
 
+		/// <inheritdoc cref="IQueryBatchItem.ProcessResults" />
+		public async Task ProcessResultsAsync(CancellationToken cancellationToken)
+		{
+			cancellationToken.ThrowIfCancellationRequested();
+			ThrowIfNotInitialized();
+
+			using (Session.SwitchCacheMode(_cacheMode))
+				await (InitializeEntitiesAndCollectionsAsync(_reader, _hydratedObjects, cancellationToken)).ConfigureAwait(false);
+
+			for (var i = 0; i < _queryInfos.Count; i++)
+			{
+				var queryInfo = _queryInfos[i];
+				if (_subselectResultKeys[i] != null)
+				{
+					queryInfo.Loader.CreateSubselects(_subselectResultKeys[i], queryInfo.Parameters, Session);
+				}
+
+				if (queryInfo.IsCacheable)
+				{
+					// This transformation must not be applied to ResultToCache.
+					queryInfo.Result =
+						queryInfo.Loader.TransformCacheableResults(
+							queryInfo.Parameters, queryInfo.CacheKey.ResultTransformer, queryInfo.Result);
+				}
+			}
+			AfterLoadCallback?.Invoke(GetResults());
+		}
+
 		/// <inheritdoc />
 		public async Task ExecuteNonBatchedAsync(CancellationToken cancellationToken)
 		{

src/NHibernate/Engine/Loading/CollectionLoadContext.cs

@@ -124,6 +124,8 @@ public IPersistentCollection GetLoadingCollection(ICollectionPersister persister
 			}
 			else
 			{
+				if (loadingCollectionEntry.StopLoading)
+					return null;
 				if (loadingCollectionEntry.ResultSet == resultSet)
 				{
 					log.Debug("found loading collection bound to current result set processing; reading row");
@@ -398,5 +400,17 @@ public override string ToString()
 		{
 			return base.ToString() + "<rs=" + ResultSet + ">";
 		}
+
+		internal void StopLoadingCollections(ICollectionPersister[] collectionPersisters)
+		{
+			foreach (var collectionKey in localLoadingCollectionKeys)
+			{
+				var loadingCollectionEntry = LoadContext.LocateLoadingCollectionEntry(collectionKey);
+				if (loadingCollectionEntry != null && Array.IndexOf(collectionPersisters, loadingCollectionEntry.Persister) >= 0)
+				{
+					loadingCollectionEntry.StopLoading = true;
+				}
+			}
+		}
 	}
 }

src/NHibernate/Engine/Loading/LoadingCollectionEntry.cs

@@ -44,6 +44,8 @@ public IPersistentCollection Collection
 			get { return collection; }
 		}
 
+		public bool StopLoading { get; set; }
+
 		public override string ToString()
 		{
 			return GetType().FullName + "<rs=" + ResultSet + ", coll=" + MessageHelper.InfoString(Persister.Role, Key) + ">@" + Convert.ToString(GetHashCode(), 16);

src/NHibernate/Loader/Loader.cs

@@ -672,6 +672,18 @@ internal void InitializeEntitiesAndCollections(
 			}
 		}
 
+		/// <summary>
+		/// Stops further collection population without actual collection initialization.
+		/// </summary>
+		internal void StopLoadingCollections(ISessionImplementor session, DbDataReader reader)
+		{
+			var collectionPersisters = CollectionPersisters;
+			if (collectionPersisters == null || collectionPersisters.Length == 0)
+				return;
+
+			session.PersistenceContext.LoadContexts.GetCollectionLoadContext(reader).StopLoadingCollections(collectionPersisters);
+		}
+
 		private void EndCollectionLoad(DbDataReader reader, ISessionImplementor session, ICollectionPersister collectionPersister)
 		{
 			//this is a query and we are loading multiple instances of the same collection role

src/NHibernate/Multi/IQueryBatchItem.cs

@@ -80,4 +80,10 @@ public partial interface IQueryBatchItem
 		/// </summary>
 		void ExecuteNonBatched();
 	}
+
+	//TODO 6.0: Remove along with ignore rule for IQueryBatchItem.ProcessResults in AsyncGenerator.yml
+	internal partial interface IQueryBatchItemWithAsyncProcessResults
+	{
+		void ProcessResults();
+	}
 }

src/NHibernate/Multi/QueryBatch.cs

@@ -153,37 +153,40 @@ protected void ExecuteBatched()
 			}
 
 			var rowCount = 0;
+			CacheBatcher cacheBatcher = null;
 			try
 			{
 				if (resultSetsCommand.HasQueries)
 				{
+					cacheBatcher = new CacheBatcher(Session);
 					using (var reader = resultSetsCommand.GetReader(Timeout))
 					{
-						var cacheBatcher = new CacheBatcher(Session);
 						foreach (var query in _queries)
 						{
 							if (query.CachingInformation != null)
 							{
-								foreach (var cachingInfo in query.CachingInformation.Where(ci => ci.IsCacheable))
+								foreach (var cachingInfo in query.CachingInformation)
 								{
 									cachingInfo.SetCacheBatcher(cacheBatcher);
 								}
 							}
 
 							rowCount += query.ProcessResultsSet(reader);
 						}
-						cacheBatcher.ExecuteBatch();
 					}
 				}
 
-				// Query cacheable results must be cached untransformed: the put does not need to wait for
-				// the ProcessResults.
-				PutCacheableResults();
-
 				foreach (var query in _queries)
 				{
-					query.ProcessResults();
+					//TODO 6.0: Replace with query.ProcessResults();
+					if (query is IQueryBatchItemWithAsyncProcessResults q)
+						q.ProcessResults();
+					else
+						query.ProcessResults();
 				}
+
+				cacheBatcher?.ExecuteBatch();
+				PutCacheableResults();
 			}
 			catch (Exception sqle)
 			{