Integrate universal query batch in Future

Fixes #752
Fixes #1293
Fixes partially #840 (multi-criteria/query not fixed)
Fixes partially #1344 (multi-criteria not fixed)

Author: bahusoid

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

@@ -176,6 +176,36 @@ public async Task CanUseFutureQueryAsync()
 			}
 		}
 
+		[Test]
+		public async Task CanUseFutureQueryAndQueryOverForSatelessSessionAsync()
+		{
+			IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();
+
+			using (var s = Sfi.OpenStatelessSession())
+			{
+				var persons10 = s.Query<Person>()
+					.Take(10)
+					.ToFuture();
+				var persons5 = s.QueryOver<Person>()
+					.Take(5)
+					.Future();
+
+				using (var logSpy = new SqlLogSpy())
+				{
+					foreach (var person in await (persons5.GetEnumerableAsync()))
+					{
+					}
+
+					foreach (var person in await (persons10.GetEnumerableAsync()))
+					{
+					}
+
+					var events = logSpy.Appender.GetEvents();
+					Assert.AreEqual(1, events.Length);
+				}
+			}
+		}
+
 		[Test]
 		public async Task CanUseFutureQueryWithAnonymousTypeAsync()
 		{
@@ -412,5 +442,120 @@ public async Task UsingManyParametersAndQueries_DoesNotCauseParameterNameCollisi
 				await (tx.CommitAsync());
 			}
 		}
+
+		[Test]
+		public async Task FutureCombineCachedAndNonCachedQueriesAsync()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var p1 = new Person
+				{
+					Name = "Person name",
+					Age = 15
+				};
+				var p2 = new Person
+				{
+					Name = "Person name",
+					Age = 20
+				};
+
+				await (s.SaveAsync(p1));
+				await (s.SaveAsync(p2));
+				await (tx.CommitAsync());
+			}
+
+			using (var s = Sfi.OpenSession())
+			{
+				var list = new List<IFutureEnumerable<Person>>();
+				for (var i = 0; i < 5; i++)
+				{
+					var i1 = i;
+					var query = s.Query<Person>().Where(x => x.Age > i1);
+					list.Add(query.WithOptions(x => x.SetCacheable(true)).ToFuture());
+				}
+
+				foreach (var query in list)
+				{
+					var result = (await (query.GetEnumerableAsync())).ToList();
+					Assert.That(result.Count, Is.EqualTo(2));
+				}
+			}
+
+			//Check query.List returns data from cache
+			Sfi.Statistics.IsStatisticsEnabled = true;
+			using (var s = Sfi.OpenSession())
+			{
+				var list = new List<IEnumerable<Person>>();
+				for (var i = 0; i < 5; i++)
+				{
+					var i1 = i;
+					var query = s.Query<Person>().Where(x => x.Age > i1);
+
+					list.Add(await (query.WithOptions(x => x.SetCacheable(true)).ToListAsync()));
+				}
+
+				foreach (var query in list)
+				{
+					var result = query.ToList();
+					Assert.That(result.Count, Is.EqualTo(2));
+				}
+
+				Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(0), "Queries must be retrieved from cache");
+			}
+
+			//Check another Future returns data from cache
+			Sfi.Statistics.Clear();
+			using (var s = Sfi.OpenSession())
+			{
+				var list = new List<IFutureEnumerable<Person>>();
+				//Reverse order of queries added to cache
+				for (var i = 5 - 1; i >= 0; i--)
+				{
+					var i1 = i;
+					var query = s.Query<Person>().Where(x => x.Age > i1);
+
+					list.Add(query.WithOptions(x => x.SetCacheable(true)).ToFuture());
+				}
+
+				foreach (var query in list)
+				{
+					var result = (await (query.GetEnumerableAsync())).ToList();
+					Assert.That(result.Count, Is.EqualTo(2));
+				}
+
+				Assert.That(Sfi.Statistics.PrepareStatementCount , Is.EqualTo(0), "Future queries must be retrieved from cache");
+			}
+
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				await (s.DeleteAsync("from Person"));
+				await (tx.CommitAsync());
+			}
+		}
+
+		[Test]
+		public async Task FutureAutoFlushAsync()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				s.FlushMode = FlushMode.Auto;
+				var p1 = new Person
+				{
+					Name = "Person name",
+					Age = 15
+				};
+				await (s.SaveAsync(p1));
+				await (s.FlushAsync());
+
+				await (s.DeleteAsync(p1));
+				var count = await (s.QueryOver<Person>().ToRowCountQuery().FutureValue<int>().GetValueAsync());
+				await (tx.CommitAsync());
+
+				Assert.That(count, Is.EqualTo(0), "Session wasn't auto flushed.");
+			}
+		}
 	}
 }

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

@@ -27,6 +27,34 @@ namespace NHibernate.Test.Futures
 	public class QueryBatchFixtureAsync : TestCaseMappingByCode
 	{
 		private Guid _parentId;
+		private Guid _eagerId;
+
+		[Test]
+		public async Task CanCombineCriteriaAndHqlInFutureAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				var future1 = session.QueryOver<EntityComplex>()
+						.Where(x => x.Version >= 0)
+						.TransformUsing(new ListTransformerToInt()).Future<int>();
+
+				var future2 = session.Query<EntityComplex>().Where(ec => ec.Version > 2).ToFuture();
+				var future3 = session.Query<EntitySimpleChild>().Select(sc => sc.Name).ToFuture();
+
+				var future4 = session
+						.Query<EntitySimpleChild>()
+						.ToFutureValue(sc => sc.FirstOrDefault());
+
+				Assert.That((await (future1.GetEnumerableAsync())).Count(), Is.GreaterThan(0), "Empty results are not expected");
+				Assert.That((await (future2.GetEnumerableAsync())).Count(), Is.EqualTo(0), "This query should not return results");
+				Assert.That((await (future3.GetEnumerableAsync())).Count(), Is.GreaterThan(1), "Empty results are not expected");
+				Assert.That(await (future4.GetValueAsync()), Is.Not.Null, "Loaded entity should not be null");
+
+				if (SupportsMultipleQueries)
+					Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1));
+			}
+		}
 
 		[Test]
 		public async Task CanCombineCriteriaAndHqlInBatchAsync()
@@ -63,6 +91,44 @@ public async Task CanCombineCriteriaAndHqlInBatchAsync()
 			}
 		}
 
+		[Test]
+		public async Task CanCombineCriteriaAndHqlInBatchAsFutureAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var batch = session
+					.CreateQueryBatch();
+
+				var future1 = batch.AddAsFuture<int>(
+					session
+						.QueryOver<EntityComplex>()
+						.Where(x => x.Version >= 0)
+						.TransformUsing(new ListTransformerToInt()));
+
+				var future2 = batch.AddAsFutureValue<Guid>(session.QueryOver<EntityComplex>().Where(x => x.Version >= 1).Select(x => x.Id));
+
+				var future3 = batch.AddAsFuture(session.Query<EntityComplex>().Where(ec => ec.Version > 2));
+				var future4 = batch.AddAsFutureValue(session.Query<EntityComplex>().Where(ec => ec.Version > 2), ec => ec.FirstOrDefault());
+
+				var future5 = batch.AddAsFuture<EntitySimpleChild>(
+					session.CreateSQLQuery(
+								$"select * from {nameof(EntitySimpleChild)}")
+							.AddEntity(typeof(EntitySimpleChild)));
+
+				using (var sqlLog = new SqlLogSpy())
+				{
+					var future1List = (await (future1.GetEnumerableAsync())).ToList();
+					var future2Value = await (future2.GetValueAsync());
+					var future3List = (await (future3.GetEnumerableAsync())).ToList();
+					var future4Value = await (future4.GetValueAsync());
+					var future5List = (await (future5.GetEnumerableAsync())).ToList();
+
+					if (SupportsMultipleQueries)
+						Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1));
+				}
+			}
+		}
+
 		[Test]
 		public async Task CanFetchCollectionInBatchAsync()
 		{
@@ -119,6 +185,30 @@ public async Task AfterLoadCallbackAsync()
 			}
 		}
 
+		//NH-3350 (Duplicate records using Future())
+		[Test]
+		public async Task SameCollectionFetchesAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var entiyComplex = session.QueryOver<EntityComplex>().Where(c => c.Id == _parentId).FutureValue();
+
+				session.QueryOver<EntityComplex>()
+						.Fetch(SelectMode.Fetch, ec => ec.ChildrenList)
+						.Where(c => c.Id == _parentId).Future();
+
+				session.QueryOver<EntityComplex>()
+						.Fetch(SelectMode.Fetch, ec => ec.ChildrenList)
+						.Where(c => c.Id == _parentId).Future();
+
+				var parent = await (entiyComplex.GetValueAsync());
+				Assert.That(NHibernateUtil.IsInitialized(parent), Is.True);
+				Assert.That(NHibernateUtil.IsInitialized(parent.ChildrenList), Is.True);
+				Assert.That(parent.ChildrenList.Count, Is.EqualTo(2));
+				
+			}
+		}
+
 		#region Test Setup
 
 		protected override HbmMapping GetMappings()
@@ -264,6 +354,7 @@ protected override void OnSetUp()
 				transaction.Commit();
 
 				_parentId = complex.Id;
+				_eagerId = eager.Id;
 			}
 		}
 

src/NHibernate.Test/Async/NHSpecificTest/NH1989/Fixture.cs

@@ -163,7 +163,6 @@ public async Task SecondLevelCacheWithMixedCacheableAndNonCacheableFutureAsync()
 						.SetCacheable(true)
 						.FutureValue<User>();
 
-				// non cacheable Future causes batch to be non-cacheable
 				int count =
 					await (s.CreateCriteria<User>()
 						.SetProjection(Projections.RowCount())
@@ -190,7 +189,9 @@ public async Task SecondLevelCacheWithMixedCacheableAndNonCacheableFutureAsync()
 						.FutureValue<int>()
 						.GetValueAsync());
 
-				Assert.That(await (userFuture.GetValueAsync()), Is.Null,
+				Assert.That(await (userFuture.GetValueAsync()), Is.Not.Null,
+					"query results should come from cache");
+				Assert.That(count, Is.EqualTo(0),
 					"query results should not come from cache");
 			}
 		}
@@ -216,7 +217,6 @@ public async Task SecondLevelCacheWithMixedCacheRegionsFutureAsync()
 						.SetCacheRegion("region1")
 						.FutureValue<User>();
 
-				// different cache-region causes batch to be non-cacheable
 				int count =
 					await (s.CreateCriteria<User>()
 						.SetProjection(Projections.RowCount())
@@ -240,6 +240,13 @@ public async Task SecondLevelCacheWithMixedCacheRegionsFutureAsync()
 						.SetCacheRegion("region1")
 						.FutureValue<User>();
 
+				IFutureValue<User> userFutureWrongRegion =
+					s.CreateCriteria<User>()
+						.Add(Restrictions.NaturalId().Set("Name", "test"))
+						.SetCacheable(true)
+						.SetCacheRegion("region2")
+						.FutureValue<User>();
+
 				int count =
 					await (s.CreateCriteria<User>()
 						.SetProjection(Projections.RowCount())
@@ -248,8 +255,23 @@ public async Task SecondLevelCacheWithMixedCacheRegionsFutureAsync()
 						.FutureValue<int>()
 						.GetValueAsync());
 
-				Assert.That(await (userFuture.GetValueAsync()), Is.Null,
-					"query results should not come from cache");
+				int countWrongRegion =
+					await (s.CreateCriteria<User>()
+						.SetProjection(Projections.RowCount())
+						.SetCacheable(true)
+						.SetCacheRegion("region1")
+						.FutureValue<int>()
+						.GetValueAsync());
+
+				Assert.That(await (userFuture.GetValueAsync()), Is.Not.Null,
+					"query results should come from cache");
+				Assert.That(count, Is.EqualTo(1),
+					"query results should come from cache");
+
+				Assert.That(await (userFutureWrongRegion.GetValueAsync()), Is.Null,
+					"query results from wrong cache region");
+				Assert.That(countWrongRegion, Is.EqualTo(0),
+					"query results from wrong cache region");
 			}
 		}