Merge branch 'master' into RefactorSequentialSelect

Author: fredericDelaporte

Tools/packages.config

@@ -7,7 +7,7 @@
   <package id="NUnit.Extension.NUnitV2ResultWriter" version="3.6.0" targetFramework="net461" />
   <package id="NUnit.Extension.TeamCityEventListener" version="1.0.2" targetFramework="net461" />
   <package id="NUnit.Extension.VSProjectLoader" version="3.6.0" targetFramework="net461" />
-  <package id="CSharpAsyncGenerator.CommandLine" version="0.8.2.9" targetFramework="net461" />
+  <package id="CSharpAsyncGenerator.CommandLine" version="0.13.1" targetFramework="net461" />
   <package id="vswhere" version="2.1.4" targetFramework="net461" />
   <package id="gitreleasemanager" version="0.7.0" targetFramework="net461" />
 </packages>

build-common/NHibernate.props

@@ -24,7 +24,7 @@
     <PackageProjectUrl>http://nhibernate.info</PackageProjectUrl>
     <PackageIconUrl>https://raw.githubusercontent.com/nhibernate/nhibernate-core/master/logo/NHibernate-NuGet.png</PackageIconUrl>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <PackageLicenseUrl>https://raw.githubusercontent.com/nhibernate/nhibernate-core/master/LICENSE.txt</PackageLicenseUrl>
+    <PackageLicenseExpression>LGPL-2.1-only</PackageLicenseExpression>
     <PackageReleaseNotes>https://github.com/nhibernate/nhibernate-core/blob/$(VersionPrefix)/releasenotes.txt</PackageReleaseNotes>
     <RepositoryUrl>https://github.com/nhibernate/nhibernate-core.git</RepositoryUrl>
     <RepositoryType>git</RepositoryType>

src/NHibernate.Test/Async/Criteria/Lambda/ProjectIntegrationFixture.cs

@@ -99,6 +99,8 @@ public async Task ProjectTransformToDtoAsync()
 				var actual = await (s.QueryOver<Person>()
 					.SelectList(list => list
 						.SelectGroup(p => p.Name).WithAlias(() => summary.Name)
+						//GH1985: DateTime.xxxx are not supported in SelectGroup
+						.SelectGroup(p => p.BirthDate.Year).WithAlias(() => summary.BirthYear)
 						.Select(Projections.RowCount()).WithAlias(() => summary.Count))
 					.OrderByAlias(() => summary.Name).Asc
 					.TransformUsing(Transformers.AliasToBean<PersonSummary>())
@@ -111,5 +113,26 @@ public async Task ProjectTransformToDtoAsync()
 				Assert.That(actual[1].Count, Is.EqualTo(1));
 			}
 		}
+
+		[Test]
+		public async Task ProjecionCountDistinctAsync()
+		{
+			if (!TestDialect.SupportsCountDistinct)
+				Assert.Ignore("Dialect does not support count distinct");
+
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var actual
+					= (await (s.QueryOver<Person>()
+					.SelectList(l =>
+					l.SelectCountDistinct(p => p.BirthDate.Year)
+					.SelectCountDistinct(p => p.Name))
+					.ListAsync<object[]>())).FirstOrDefault();
+
+				Assert.That((int) actual[0], Is.EqualTo(1), "distinct count by birth year");
+				Assert.That((int) actual[1], Is.EqualTo(2), "distinct count by name");
+			}
+		}
 	}
 }

src/NHibernate.Test/Async/Criteria/Lambda/SubQueryIntegrationFixture.cs

@@ -166,5 +166,32 @@ public async Task SubQueryAsync()
 				Assert.That(nameAndChildCount[1].ChildCount, Is.EqualTo(1));
 			}
 		}
+
+		//NH-3493 - Cannot use alias between more than 1 level of nested queries
+		[Test]
+		public async Task ThreeLevelSubqueryAsync()
+		{
+			if (!Dialect.SupportsScalarSubSelects)
+				Assert.Ignore("Dialect does not support scalar sub-select");
+
+			Person p = null;
+			var detachedCriteria2 = DetachedCriteria.For<Person>("vf_inner_2")
+				.SetProjection(Projections.Id())
+				.Add(Restrictions.Eq($@"mk.{nameof(p.Age)}", 20))
+				.Add(Restrictions.EqProperty("vf_inner_2.Id", "vf_inner.Id"));
+
+			var detachedCriteria1 = DetachedCriteria.For<Person>("vf_inner")
+				.SetProjection(Projections.Id())
+				.Add(Subqueries.Exists(detachedCriteria2))
+				.Add(Restrictions.EqProperty("vf_inner.Id", "vf.Id"));
+
+			using (var s = OpenSession())
+			{
+				await (s.CreateCriteria<Person>("vf")
+					.CreateAlias($"vf.{nameof(p.Father)}", "mk")
+					.AddOrder(Order.Asc(Projections.SubQuery(detachedCriteria1)))
+					.ListAsync<Person>());
+			}
+		}
 	}
 }

src/NHibernate.Test/Async/LazyProperty/LazyPropertyFixture.cs

@@ -9,6 +9,7 @@
 
 
 using System.Collections;
+using System.Collections.Generic;
 using System.Linq;
 using NHibernate.Cfg;
 using NHibernate.Intercept;
@@ -81,6 +82,7 @@ protected override void OnTearDown()
 			using (var s = OpenSession())
 			using (var tx = s.BeginTransaction())
 			{
+				s.CreateQuery("delete from Word").ExecuteUpdate();
 				s.CreateQuery("delete from Book").ExecuteUpdate();
 				tx.Commit();
 			}
@@ -345,5 +347,56 @@ public async Task CacheShouldNotContainLazyPropertiesAsync()
 			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
 			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Image"), Is.False);
 		}
+
+		[Test]
+		public async Task CanMergeTransientWithLazyPropertyInCollectionAsync()
+		{
+			Book book;
+
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				book = new Book
+				{
+					Name = "some name two",
+					Id = 3,
+					ALotOfText = "a lot of text two..."
+				};
+				// This should insert a new entity.
+				await (s.MergeAsync(book));
+				await (tx.CommitAsync());
+			}
+
+			using (var s = OpenSession())
+			{
+				book = await (s.GetAsync<Book>(3));
+				Assert.That(book, Is.Not.Null);
+				Assert.That(book.Name, Is.EqualTo("some name two"));
+				Assert.That(book.ALotOfText, Is.EqualTo("a lot of text two..."));
+
+			}
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				book.Words = new List<Word>();
+				var word = new Word
+				{
+					Id = 2,
+					Parent = book,
+					Content = new byte[1] {0}
+				};
+
+				book.Words.Add(word);
+				await (s.MergeAsync(book));
+				await (tx.CommitAsync());
+			}
+
+			using (var s = OpenSession())
+			{
+				book = await (s.GetAsync<Book>(3));
+				Assert.That(book.Words.Any(), Is.True);
+				Assert.That(book.Words.First().Content, Is.EqualTo(new byte[1] { 0 }));
+			}
+		}
 	}
 }

src/NHibernate.Test/Async/Linq/QueryTimeoutTests.cs

@@ -114,15 +114,8 @@ public TimeoutCatchingNonBatchingBatcher(ConnectionManager connectionManager, II
 
 			public override Task<DbDataReader> ExecuteReaderAsync(DbCommand cmd, CancellationToken cancellationToken)
 			{
-				try
-				{
-					LastCommandTimeout = cmd.CommandTimeout;
-					return base.ExecuteReaderAsync(cmd, cancellationToken);
-				}
-				catch (System.Exception ex)
-				{
-					return Task.FromException<DbDataReader>(ex);
-				}
+				LastCommandTimeout = cmd.CommandTimeout;
+				return base.ExecuteReaderAsync(cmd, cancellationToken);
 			}
 
 			public override DbDataReader ExecuteReader(DbCommand cmd)
@@ -150,15 +143,8 @@ public partial class TimeoutCatchingNonBatchingBatcher : NonBatchingBatcher
 
 			public override Task<DbDataReader> ExecuteReaderAsync(DbCommand cmd, CancellationToken cancellationToken)
 			{
-				try
-				{
-					LastCommandTimeout = cmd.CommandTimeout;
-					return base.ExecuteReaderAsync(cmd, cancellationToken);
-				}
-				catch (System.Exception ex)
-				{
-					return Task.FromException<DbDataReader>(ex);
-				}
+				LastCommandTimeout = cmd.CommandTimeout;
+				return base.ExecuteReaderAsync(cmd, cancellationToken);
 			}
 		}
 	}

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

@@ -158,14 +158,7 @@ private partial class SubstituteDbCommand : DbCommand
 
 			protected override Task<DbDataReader> ExecuteDbDataReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
 			{
-				try
-				{
-					return Task.FromResult<DbDataReader>(_substituteReader);
-				}
-				catch (Exception ex)
-				{
-					return Task.FromException<DbDataReader>(ex);
-				}
+				return Task.FromResult<DbDataReader>(_substituteReader);
 			}
 
 			public override Task<int> ExecuteNonQueryAsync(CancellationToken cancellationToken)

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

@@ -0,0 +1,36 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System.Linq;
+using NUnit.Framework;
+using NHibernate.Linq;
+
+namespace NHibernate.Test.NHSpecificTest.GH1962
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class FixtureAsync : BugTestCase
+	{
+		[Test]
+		[KnownBug("#1962")]
+		public async Task LinqShouldBeValidAsync()
+		{
+			using (var session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				var result =
+					await (session
+						.Query<Product>()
+						.CountAsync(p => p.OrderDetails.Any(od => od.Order.OrderDetails[0] == od)));
+				Assert.That(result, Is.EqualTo(0));
+			}
+		}
+	}
+}

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

@@ -573,20 +573,13 @@ protected void ClearSecondLevelCacheFor(System.Type entity)
 
 		protected Task ClearCollectionCacheAsync<T>(Expression<Func<T, IEnumerable>> pathToCollection, CancellationToken cancellationToken = default(CancellationToken))
 		{
-			try
-			{
-				var rootEntityTypeFullPath = typeof(T).FullName;
-				var memberExpression = pathToCollection.Body as MemberExpression;
-				if (memberExpression == null)
-					return Task.FromException<object>(new ArgumentException("pathToCollection should be member expression"));
+			var rootEntityTypeFullPath = typeof(T).FullName;
+			var memberExpression = pathToCollection.Body as MemberExpression;
+			if (memberExpression == null)
+				return Task.FromException<object>(new ArgumentException("pathToCollection should be member expression"));
 
-				var role = $"{rootEntityTypeFullPath}.{memberExpression.Member.Name}";
-				return Sfi.EvictCollectionAsync(role, cancellationToken);
-			}
-			catch (Exception ex)
-			{
-				return Task.FromException<object>(ex);
-			}
+			var role = $"{rootEntityTypeFullPath}.{memberExpression.Member.Name}";
+			return Sfi.EvictCollectionAsync(role, cancellationToken);
 		}
 
 		protected void ClearCollectionCache<T>(Expression<Func<T, IEnumerable>> pathToCollection)

src/NHibernate.Test/Async/SessionBuilder/Fixture.cs

@@ -189,51 +189,6 @@ private void CanSetFlushMode<T>(T sb) where T : ISessionBuilder<T>
 				FlushMode.Always, FlushMode.Auto, FlushMode.Commit, FlushMode.Manual);
 		}
 
-		[Test]
-		public async Task CanSetInterceptorAsync()
-		{
-			var sb = Sfi.WithOptions();
-			await (CanSetInterceptorAsync(sb));
-			using (var s = sb.OpenSession())
-			{
-				await (CanSetInterceptorAsync(s.SessionWithOptions()));
-			}
-		}
-
-		private Task CanSetInterceptorAsync<T>(T sb) where T : ISessionBuilder<T>
-		{
-			try
-			{
-				var sbType = sb.GetType().Name;
-				// Do not use .Instance here, we want another instance.
-				var interceptor = new EmptyInterceptor();
-				var options = DebugSessionFactory.GetCreationOptions(sb);
-
-				Assert.AreEqual(Sfi.Interceptor, options.SessionInterceptor, $"{sbType}: Initial value");
-				var fsb = sb.Interceptor(interceptor);
-				Assert.AreEqual(interceptor, options.SessionInterceptor, $"{sbType}: After call with an interceptor");
-				Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after call with an interceptor");
-
-				if (sb is ISharedSessionBuilder ssb)
-				{
-					var fssb = ssb.Interceptor();
-					Assert.AreEqual(EmptyInterceptor.Instance, options.SessionInterceptor, $"{sbType}: After call with shared interceptor");
-					Assert.AreEqual(sb, fssb, $"{sbType}: Unexpected fluent return on shared");
-				}
-
-				Assert.Throws<ArgumentNullException>(() => sb.Interceptor(null), $"{sbType}: After call with null");
-
-				fsb = sb.NoInterceptor();
-				Assert.AreEqual(EmptyInterceptor.Instance, options.SessionInterceptor, $"{sbType}: After no call");
-				Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after no call");
-				return Task.CompletedTask;
-			}
-			catch (Exception ex)
-			{
-				return Task.FromException<object>(ex);
-			}
-		}
-
 		private void CanSet<T, V>(T sb, Func<V, T> setter, Func<V> getter, Func<ISharedSessionBuilder> shared, V initialValue,
 			params V[] values) where T : ISessionBuilder<T>
 		{

src/NHibernate.Test/Async/SystemTransactions/DistributedSystemTransactionFixture.cs

@@ -690,16 +690,9 @@ public async Task EnforceConnectionUsageRulesOnTransactionCompletionAsync()
 
 		private Task DodgeTransactionCompletionDelayIfRequiredAsync(CancellationToken cancellationToken = default(CancellationToken))
 		{
-			try
-			{
-				if (Sfi.ConnectionProvider.Driver.HasDelayedDistributedTransactionCompletion)
-					return Task.Delay(500, cancellationToken);
-				return Task.CompletedTask;
-			}
-			catch (Exception ex)
-			{
-				return Task.FromException<object>(ex);
-			}
+			if (Sfi.ConnectionProvider.Driver.HasDelayedDistributedTransactionCompletion)
+				return Task.Delay(500, cancellationToken);
+			return Task.CompletedTask;
 		}
 
 		private void DodgeTransactionCompletionDelayIfRequired()

src/NHibernate.Test/Async/TransactionTest/TransactionNotificationFixture.cs

@@ -132,28 +132,14 @@ public partial class Synchronization : ITransactionCompletionSynchronization
 
 		public Task ExecuteBeforeTransactionCompletionAsync(CancellationToken cancellationToken)
 		{
-			try
-			{
-				BeforeExecutions += 1;
-				return Task.CompletedTask;
-			}
-			catch (Exception ex)
-			{
-				return Task.FromException<object>(ex);
-			}
+			BeforeExecutions += 1;
+			return Task.CompletedTask;
 		}
 
 		public Task ExecuteAfterTransactionCompletionAsync(bool success, CancellationToken cancellationToken)
 		{
-			try
-			{
-				AfterExecutions += 1;
-				return Task.CompletedTask;
-			}
-			catch (Exception ex)
-			{
-				return Task.FromException<object>(ex);
-			}
+			AfterExecutions += 1;
+			return Task.CompletedTask;
 		}
 	}