Merge branch '5.3.x'

# Conflicts:
#	build-common/NHibernate.props

Author: fredericDelaporte

releasenotes.txt

@@ -1,4 +1,22 @@
-Build 5.3.6
+Build 5.3.7
+=============================
+
+Release notes - NHibernate - Version 5.3.7
+
+5 issues were resolved in this release.
+
+** Bug
+
+   * #2704 IEnhancedUserType from string to bool fails in some circumstances
+   * #2702 LINQ projection of nullable enum with list fails
+   * #2693 Invalid parameter conversion with group by
+   * #2688 NoViableAltException in a delete on a many-to-one id
+
+** Task
+
+   * #2701 Release 5.3.7
+
+Build 5.3.6
 =============================
 
 Release notes - NHibernate - Version 5.3.6

src/NHibernate.Test/Async/Hql/EntityJoinHqlTest.cs

@@ -8,6 +8,7 @@
 //------------------------------------------------------------------------------
 
 
+using System;
 using System.Text.RegularExpressions;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Mapping.ByCode;
@@ -233,6 +234,21 @@ public async Task NullablePropRefWhereIdEntityNotNullShouldAddJoinAsync()
 			}
 		}
 
+		[Test(Description = "GH-2688")]
+		public async Task NullableManyToOneDeleteQueryAsync()
+		{
+			using (var session = OpenSession())
+			{
+				await (session
+					.CreateQuery(
+						"delete "
+						+ "from NullableOwner ex "
+						+ "where ex.ManyToOne.id = :id"
+					).SetParameter("id", Guid.Empty)
+					.ExecuteUpdateAsync());
+			}
+		}
+
 		[Test]
 		public async Task NullableOneToOneFetchQueryIsNotAffectedAsync()
 		{
@@ -539,6 +555,7 @@ protected override HbmMapping GetMappings()
 							m.ForeignKey("none");
 							m.NotFound(NotFoundMode.Ignore);
 						});
+					rc.ManyToOne(e => e.ManyToOne, m => m.NotFound(NotFoundMode.Ignore));
 				});
 
 

src/NHibernate.Test/Async/Linq/ByMethod/GroupByHavingTests.cs

@@ -10,6 +10,7 @@
 
 using System;
 using System.Linq;
+using NHibernate.DomainModel.Northwind.Entities;
 using NUnit.Framework;
 using NHibernate.Linq;
 
@@ -147,5 +148,45 @@ public async Task SingleKeyGroupAndCountWithHavingClauseAsync()
 			var hornRow = orderCounts.Single(row => row.CompanyName == "Around the Horn");
 			Assert.That(hornRow.OrderCount, Is.EqualTo(13));
 		}
+
+		[Test]
+		public async Task HavingWithStringEnumParameterAsync()
+		{
+			await (db.Users
+			  .GroupBy(p => p.Enum1)
+			  .Where(g => g.Key == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new StringEnumGroup {Enum = p.Enum1})
+			  .Where(g => g.Key.Enum == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new[] {p.Enum1})
+			  .Where(g => g.Key[0] == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new {p.Enum1})
+			  .Where(g => g.Key.Enum1 == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new {Test = new {Test2 = p.Enum1}})
+			  .Where(g => g.Key.Test.Test2 == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new {Test = new[] {p.Enum1}})
+			  .Where(g => g.Key.Test[0] == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToListAsync());
+		}
+
+		private class StringEnumGroup
+		{
+			public EnumStoredAsString Enum { get; set; }
+		}
 	}
 }

src/NHibernate.Test/Async/Linq/ByMethod/GroupByTests.cs

@@ -382,6 +382,40 @@ public async Task GroupByAndAnyAsync()
 			Assert.That(namesAreNotEmpty, Is.True);
 		}
 
+		[Test]
+		public async Task GroupByWithStringEnumParameterAsync()
+		{
+			await (db.Users
+			  .GroupBy(p => p.Enum1)
+			  .Select(g => g.Key == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new StringEnumGroup {Enum = p.Enum1})
+			  .Select(g => g.Key.Enum == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new[] {p.Enum1})
+			  .Select(g => g.Key[0] == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new {p.Enum1})
+			  .Select(g => g.Key.Enum1 == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new {Test = new {Test2 = p.Enum1}})
+			  .Select(g => g.Key.Test.Test2 == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
+			  .ToListAsync());
+			await (db.Users
+			  .GroupBy(p => new {Test = new[] {p.Enum1}})
+			  .Select(g => g.Key.Test[0] == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
+			  .ToListAsync());
+		}
+
+		private class StringEnumGroup
+		{
+			public EnumStoredAsString Enum { get; set; }
+		}
+
 		[Test]
 		public async Task SelectFirstElementFromProductsGroupedByUnitPriceAsync()
 		{

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

@@ -9,6 +9,7 @@
 
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Mapping.ByCode;
@@ -50,9 +51,24 @@ protected override HbmMapping GetMappings()
 						m.Type(_enumType);
 						m.Formula($"(case when Enum1 = {_unspecifiedValue} then null else Enum1 end)");
 					});
+					rc.Bag(x => x.Children, m => 
+						{
+							m.Cascade(Mapping.ByCode.Cascade.All);
+							m.Inverse(true);
+						},
+						a => a.OneToMany()
+					);
 					rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All));
 				});
 
+			mapper.Class<EnumEntityChild>(
+				rc =>
+				{
+					rc.Table("EnumEntityChild");
+					rc.Id(x => x.Id, m => m.Generator(Generators.Guid));
+					rc.Property(x => x.Name);
+				});
+
 			return mapper.CompileMappingForAllExplicitlyAddedEntities();
 		}
 
@@ -184,5 +200,25 @@ public async Task CanQueryComplexExpressionOnTestEnumAsync()
 				Assert.That(query.Count, Is.EqualTo(0));
 			}
 		}
+
+		[Test]
+		public async Task CanProjectWithListTransformationAsync()
+		{
+			using (var session = OpenSession())
+			using (var trans = session.BeginTransaction())
+			{
+				var entities = session.Query<EnumEntity>();
+
+				var query = await (entities.Select(user => new
+				{
+					user.Name,
+					simple = user.Enum1,
+					children = user.Children,
+					nullableEnum1IsLarge = user.NullableEnum1 == TestEnum.Large
+				}).ToListAsync());
+
+				Assert.That(query.Count, Is.EqualTo(10));
+			}
+		}
 	}
 }

src/NHibernate.Test/Async/NHSpecificTest/GH2704/FixtureByCode.cs

@@ -0,0 +1,82 @@
+//------------------------------------------------------------------------------
+// <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 NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using NHibernate.Linq;
+
+namespace NHibernate.Test.NHSpecificTest.GH2704
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class EnhancedUserTypeFixtureAsync : TestCaseMappingByCode
+	{
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+
+			mapper.AddMapping<Entity1Map>();
+			return mapper.CompileMappingForAllExplicitlyAddedEntities();
+		}
+
+		protected override void OnSetUp()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				session.Save(new Entity1() {Id = "id1", IsChiusa = true});
+				session.Save(new Entity1() {Id = "id2", IsChiusa = false});
+				transaction.Commit();
+			}
+		}
+
+		protected override void OnTearDown()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				session.CreateQuery("delete from System.Object").ExecuteUpdate();
+				transaction.Commit();
+			}
+		}
+
+		[Test]
+		public async Task CompareWithConstantAsync()
+		{
+			var yes = true;
+			using (var s = OpenSession())
+				Assert.IsTrue(await (s.Query<Entity1>().Where(x => x.IsChiusa == yes).AnyAsync()));
+		}
+
+		[Test]
+		public async Task NotOnPropertyAsync()
+		{
+			using (var s = OpenSession())
+				Assert.IsTrue(await (s.Query<Entity1>().Where(x => !x.IsChiusa).AllAsync(x => !x.IsChiusa)));
+		}
+
+		[Test]
+		public async Task CompareWithInlineConstantAsync()
+		{
+			using (var s = OpenSession())
+				Assert.IsTrue(await (s.Query<Entity1>().Where(x => x.IsChiusa == false).AnyAsync()));
+		}
+
+		[Test]
+		public async Task CompareWithNotOnConstantAsync()
+		{
+			var no = false;
+			using (var s = OpenSession())
+				Assert.IsTrue(await (s.Query<Entity1>().Where(x => x.IsChiusa == !no).AnyAsync()));
+		}
+	}
+}

src/NHibernate.Test/Hql/EntityJoinHqlTest.cs

@@ -1,4 +1,5 @@
-using System.Text.RegularExpressions;
+using System;
+using System.Text.RegularExpressions;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Mapping.ByCode;
 using NHibernate.Test.Hql.EntityJoinHqlTestEntities;
@@ -222,6 +223,21 @@ public void NullablePropRefWhereIdEntityNotNullShouldAddJoin()
 			}
 		}
 
+		[Test(Description = "GH-2688")]
+		public void NullableManyToOneDeleteQuery()
+		{
+			using (var session = OpenSession())
+			{
+				session
+					.CreateQuery(
+						"delete "
+						+ "from NullableOwner ex "
+						+ "where ex.ManyToOne.id = :id"
+					).SetParameter("id", Guid.Empty)
+					.ExecuteUpdate();
+			}
+		}
+
 		[Test]
 		public void NullableOneToOneFetchQueryIsNotAffected()
 		{
@@ -544,6 +560,7 @@ protected override HbmMapping GetMappings()
 							m.ForeignKey("none");
 							m.NotFound(NotFoundMode.Ignore);
 						});
+					rc.ManyToOne(e => e.ManyToOne, m => m.NotFound(NotFoundMode.Ignore));
 				});
 
 

src/NHibernate.Test/Hql/EntityJoinHqlTestEntities.cs

@@ -31,6 +31,7 @@ public class NullableOwner
 		public virtual string Name { get; set; }
 		public virtual OneToOneEntity OneToOne { get; set; }
 		public virtual PropRefEntity PropRef { get; set; }
+		public virtual OneToOneEntity ManyToOne { get; set; }
 	}
 
 	public class EntityWithCompositeId

src/NHibernate.Test/Linq/ByMethod/GroupByHavingTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using NHibernate.DomainModel.Northwind.Entities;
 using NUnit.Framework;
 
 namespace NHibernate.Test.Linq.ByMethod
@@ -135,5 +136,45 @@ public void SingleKeyGroupAndCountWithHavingClause()
 			var hornRow = orderCounts.Single(row => row.CompanyName == "Around the Horn");
 			Assert.That(hornRow.OrderCount, Is.EqualTo(13));
 		}
+
+		[Test]
+		public void HavingWithStringEnumParameter()
+		{
+			db.Users
+			  .GroupBy(p => p.Enum1)
+			  .Where(g => g.Key == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToList();
+			db.Users
+			  .GroupBy(p => new StringEnumGroup {Enum = p.Enum1})
+			  .Where(g => g.Key.Enum == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToList();
+			db.Users
+			  .GroupBy(p => new[] {p.Enum1})
+			  .Where(g => g.Key[0] == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToList();
+			db.Users
+			  .GroupBy(p => new {p.Enum1})
+			  .Where(g => g.Key.Enum1 == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToList();
+			db.Users
+			  .GroupBy(p => new {Test = new {Test2 = p.Enum1}})
+			  .Where(g => g.Key.Test.Test2 == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToList();
+			db.Users
+			  .GroupBy(p => new {Test = new[] {p.Enum1}})
+			  .Where(g => g.Key.Test[0] == EnumStoredAsString.Large)
+			  .Select(g => g.Count())
+			  .ToList();
+		}
+
+		private class StringEnumGroup
+		{
+			public EnumStoredAsString Enum { get; set; }
+		}
 	}
 }