Merge 5.3.10

Author: fredericDelaporte

releasenotes.txt

@@ -1,4 +1,28 @@
-Build 5.3.9
+Build 5.3.10
+=============================
+
+Release notes - NHibernate - Version 5.3.10
+
+11 issues were resolved in this release.
+
+** Bug
+
+   * #2891 Fix nullable entity comparison with null and implicit/cross joins
+   * #2885 Do not serialize unnecessary members in SessionFactory
+   * #2882 Fix ArgumentNullException when provider is unable to open a connection
+   * #2871 If DbTransaction.Dispose throws an exception, the AdoTransaction is left in an inconsistent state
+   * #2860 Null reference when calling Trim() on interpolated string containing null property
+   * #2858 Casting to object and back to interface in Subquery causes incorrect SQL
+   * #2856 Distinct on Composite User Type property fails
+   * #2855 Error log from ReflectHelper.TypeFromAssembly() on Linq query
+   * #2611 One-to-zero-or-one relation not returning data when checking for null
+   * #1962 Failing Linq query on element index
+
+** Task
+
+   * #2915 Release 5.3.10
+
+Build 5.3.9
 =============================
 
 Release notes - NHibernate - Version 5.3.9

src/NHibernate.DomainModel/Northwind/Entities/Animal.cs

@@ -16,7 +16,12 @@ public class Animal
 		public virtual Animal FatherOrMother => Father ?? Mother;
 	}
 
-    public abstract class Reptile : Animal
+	public interface IReptile
+	{
+		EnumStoredAsString Enum1 { get; }
+	}
+
+    public abstract class Reptile : Animal, IReptile
     {
         public virtual double BodyTemperature { get; set; }
 

src/NHibernate.Test/Associations/OneToOneFixture.cs

@@ -3,6 +3,7 @@
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Mapping.ByCode;
 using NHibernate.Test.Associations.OneToOneFixtureEntities;
+using NHibernate.Util;
 using NUnit.Framework;
 
 namespace NHibernate.Test.Associations
@@ -127,19 +128,22 @@ public void OneToOneCompositeQueryOverCompareWithJoinById()
 				Assert.That(loadedEntity, Is.Not.Null);
 			}
 		}
-		
+
 		//GH-2064
 		[Test]
 		public void OneToOneCompositeQuerySelectProjection()
 		{
+			using(var logSpy = new LogSpy(typeof(ReflectHelper)))
 			using (var session = OpenSession())
 			{
 				var loadedProjection = session.Query<Parent>().Select(x => new {x.OneToOneComp, x.Key}).FirstOrDefault();
 
 				Assert.That(loadedProjection.OneToOneComp, Is.Not.Null);
+				// GH-2855 Error is logged
+				Assert.That(logSpy.GetWholeLog(), Is.Empty);
 			}
 		}
-		
+
 		//NH-3178 (GH-1125)
 		[Test]
 		public void OneToOneQueryOverSelectProjection()

src/NHibernate.Test/Async/Associations/OneToOneFixture.cs

@@ -13,6 +13,7 @@
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Mapping.ByCode;
 using NHibernate.Test.Associations.OneToOneFixtureEntities;
+using NHibernate.Util;
 using NUnit.Framework;
 using NHibernate.Linq;
 
@@ -139,19 +140,22 @@ public async Task OneToOneCompositeQueryOverCompareWithJoinByIdAsync()
 				Assert.That(loadedEntity, Is.Not.Null);
 			}
 		}
-		
+
 		//GH-2064
 		[Test]
 		public async Task OneToOneCompositeQuerySelectProjectionAsync()
 		{
+			using(var logSpy = new LogSpy(typeof(ReflectHelper)))
 			using (var session = OpenSession())
 			{
 				var loadedProjection = await (session.Query<Parent>().Select(x => new {x.OneToOneComp, x.Key}).FirstOrDefaultAsync());
 
 				Assert.That(loadedProjection.OneToOneComp, Is.Not.Null);
+				// GH-2855 Error is logged
+				Assert.That(logSpy.GetWholeLog(), Is.Empty);
 			}
 		}
-		
+
 		//NH-3178 (GH-1125)
 		[Test]
 		public async Task OneToOneQueryOverSelectProjectionAsync()

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

@@ -26,7 +26,7 @@ namespace NHibernate.Test.Hql
 	[TestFixture]
 	public class EntityJoinHqlTestAsync : TestCaseMappingByCode
 	{
-		private const string _customEntityName = "CustomEntityName";
+		private const string _customEntityName = "CustomEntityName.Test";
 		private EntityWithCompositeId _entityWithCompositeId;
 		private EntityWithNoAssociation _noAssociation;
 		private EntityCustomEntityName _entityWithCustomEntityName;
@@ -51,6 +51,46 @@ public async Task CanJoinNotAssociatedEntityAsync()
 			}
 		}
 
+		[Test]
+		public async Task CanJoinNotAssociatedEntityFullNameAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntityComplex entityComplex = 
+				await (session
+					.CreateQuery("select ex " +
+						"from EntityWithNoAssociation root " +
+						$"left join {typeof(EntityComplex).FullName} ex with root.Complex1Id = ex.Id")
+						.SetMaxResults(1)
+					.UniqueResultAsync<EntityComplex>());
+
+				Assert.That(entityComplex, Is.Not.Null);
+				Assert.That(NHibernateUtil.IsInitialized(entityComplex), Is.True);
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
+
+		[Test]
+		public async Task CanJoinNotAssociatedInterfaceFullNameAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntityComplex entityComplex = 
+				await (session
+					.CreateQuery("select ex " +
+						"from EntityWithNoAssociation root " +
+						$"left join {typeof(IEntityComplex).FullName} ex with root.Complex1Id = ex.Id")
+						.SetMaxResults(1)
+					.UniqueResultAsync<EntityComplex>());
+
+				Assert.That(entityComplex, Is.Not.Null);
+				Assert.That(NHibernateUtil.IsInitialized(entityComplex), Is.True);
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
+
 		[Test]
 		public async Task CanJoinNotAssociatedEntity_OnKeywordAsync()
 		{
@@ -302,8 +342,18 @@ public async Task NullableEntityProjectionAsync()
 
 				var fullList = await (session.Query<NullableOwner>().Select(x => new {x.Name, ManyToOneId = (Guid?) x.ManyToOne.Id}).ToListAsync());
 				var withValidManyToOneList = await (session.Query<NullableOwner>().Where(x => x.ManyToOne != null).Select(x => new {x.Name, ManyToOneId = (Guid?) x.ManyToOne.Id}).ToListAsync());
+				var withValidManyToOneList2 = await (session.CreateQuery("from NullableOwner ex where not ex.ManyToOne is null").ListAsync<NullableOwner>());
+				var withNullManyToOneList = await (session.Query<NullableOwner>().Where(x => x.ManyToOne == null).ToListAsync());
+				var withNullManyToOneJoinedList =
+					await ((from x in session.Query<NullableOwner>()
+							from x2 in session.Query<NullableOwner>()
+							where x == x2 && x.ManyToOne == null && x.OneToOne.Name == null
+							select x2).ToListAsync());
 				Assert.That(fullList.Count, Is.EqualTo(2));
 				Assert.That(withValidManyToOneList.Count, Is.EqualTo(0));
+				Assert.That(withValidManyToOneList2.Count, Is.EqualTo(0));
+				Assert.That(withNullManyToOneList.Count, Is.EqualTo(2));
+				Assert.That(withNullManyToOneJoinedList.Count, Is.EqualTo(2));
 			}
 		}
 

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

@@ -1412,5 +1412,15 @@ public void ReplaceFunctionWithNullArgumentAsync()
 				}, Throws.Nothing, "Expected REPLACE(FirstName, LastName, NULL) to be supported");
 			Assert.That(results, Is.Not.Null);
 		}
+
+		[Test(Description = "GH-2860")]
+		public async Task StringFormatWithTrimAsync()
+		{
+			var q =
+				from e in db.Employees
+				select new {Name = $"{e.FirstName} {e.LastName}".Trim(), Phone = e.Address.PhoneNumber};
+			var items = await (q.ToListAsync());
+			Assert.AreEqual(9, items.Count);
+		}
 	}
 }

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

@@ -19,11 +19,9 @@ namespace NHibernate.Test.NHSpecificTest.GH1962
 	public class FixtureAsync : BugTestCase
 	{
 		[Test]
-		[KnownBug("#1962")]
 		public async Task LinqShouldBeValidAsync()
 		{
 			using (var session = OpenSession())
-			using (session.BeginTransaction())
 			{
 				var result =
 					await (session

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

@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <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.GH2856
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class FixtureAsync : BugTestCase
+	{
+		protected override void OnSetUp()
+		{
+			using (var s = Sfi.OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				s.Save(new Entity {Name = "Company", Phone = new PhoneNumber("745-555-1234"),});
+				s.Save(new Entity {Name = "Bob", Phone = new PhoneNumber("745-555-1234", "x123"),});
+				s.Save(new Entity {Name = "Jane", Phone = new PhoneNumber("745-555-1235"),});
+				s.Flush();
+				t.Commit();
+			}
+		}
+
+		protected override void OnTearDown()
+		{
+			using (var s = Sfi.OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				s.Delete("from Entity");
+				s.Flush();
+				t.Commit();
+			}
+		}
+
+		[Test]
+		public async Task CanDistinctOnCompositeUserTypeAsync()
+		{
+			using (var s = OpenSession())
+			{
+				var numbers = await (s.Query<Entity>().Select(x => x.Phone.Ext).Distinct().ToListAsync());
+				Assert.That(numbers.Count, Is.EqualTo(2));
+			}
+		}
+	}
+}