Merge branch '5.3.x'

# Conflicts:
#	build-common/NHibernate.props

Author: fredericDelaporte

releasenotes.txt

@@ -1,4 +1,35 @@
-Build 5.3.5
+Build 5.3.6
+=============================
+
+Release notes - NHibernate - Version 5.3.6
+
+12 issues were resolved in this release.
+
+** Bug
+
+   * #2659 IQueryable<T> filter by subquery gives "Item with Same Key has already been added"
+   * #2649 Invalid parameter conversion for enums mapped in sub-classes
+   * #2646 Invalid generated sql with linq any in select and composite keys
+   * #2642 Linq expression parser removes required Convert nodes
+   * #2631 IndexOutOfRange exception with One-to-One mapping
+   * #2627 Null reference on Merge for detached unsaved entity
+   * #2626 WHERE IN SELECT uses wrong column
+   * #2608 Delay entity insert may fail with Merge
+   * #2544 Recognition error occurs using System.Linq.Queryable.Contains
+
+** Improvement
+
+   * #2677 Missing ConfigureAwait in FutureEnumerable.GetEnumerableAsync
+   * #2656 Make sure dbcommand is disposed
+
+** Task
+
+   * #2676 Release 5.3.6
+
+As part of releasing 5.3.6, one missing 5.3.0 possible breaking change has been added, about
+Merge no more triggering immediate generation of identifier. See 5.3.0 possible breaking changes.
+
+Build 5.3.5
 =============================
 
 Release notes - NHibernate - Version 5.3.5
@@ -121,7 +152,7 @@ Release notes - NHibernate - Version 5.3.0
         * `update` and `delete` statements will now take into account any enabled filter on the entities
           they update or delete, while previously they were ignoring them. (`insert` statements will also take
           them into account, but previously they were failing instead of ignoring enabled filters.)
-        * ISession.Persist will no more trigger immediate generation of identifier.
+        * ISession.Persist and ISession.Merge will no more trigger immediate generation of identifier.
         * Bags will no more be loaded with "null" entities, they will be filtered out.
         * Setting the value of an uninitialized lazy property will no more trigger loading of all the lazy
           properties of the entity.

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

@@ -19,6 +19,8 @@ public class Animal
     public abstract class Reptile : Animal
     {
         public virtual double BodyTemperature { get; set; }
+
+		public virtual EnumStoredAsString Enum1 { get; set; }
     }
 
     public class Lizard : Reptile { }

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

@@ -47,6 +47,8 @@ public virtual DateTime? OrderDate
             set { _orderDate = value; }
         }
 
+        public virtual DateTime RequiredOrderDate { get; set; }
+
         public virtual DateTime? RequiredDate
         {
             get { return _requiredDate; }
@@ -106,4 +108,4 @@ public virtual void RemoveOrderLine(OrderLine orderLine)
             }
         }
     }
-}
+}

src/NHibernate.DomainModel/Northwind/Mappings/Animal.hbm.xml

@@ -19,6 +19,9 @@
     <joined-subclass name="Reptile">
       <key column="Animal"/>
       <property name="BodyTemperature"/>
+      <property name="Enum1" type="NHibernate.DomainModel.Northwind.Entities.EnumStoredAsStringType, NHibernate.DomainModel"
+                formula="('Unspecified')" insert="false" update="false">
+      </property>
 
       <joined-subclass name="Lizard">
         <key column="Reptile"/>
@@ -39,4 +42,4 @@
       </joined-subclass>
     </joined-subclass>
   </class>
-</hibernate-mapping>
+</hibernate-mapping>

src/NHibernate.DomainModel/Northwind/Mappings/Order.hbm.xml

@@ -17,6 +17,9 @@
 		<property name="OrderDate" column="OrderDate" type="DateTime"
 							access="field.camelcase-underscore"/>
 
+
+		<property name="RequiredOrderDate" formula="OrderDate" insert="false" update="false" />
+
 		<property name="RequiredDate" column="RequiredDate" type="DateTime"
 							access="field.camelcase-underscore"/>
 
@@ -60,4 +63,4 @@
 
 	</class>
 
-</hibernate-mapping>
+</hibernate-mapping>

src/NHibernate.Test/Async/CompositeId/CompositeIdFixture.cs

@@ -10,8 +10,10 @@
 
 using System;
 using System.Collections;
+using System.Linq;
 using NHibernate.Dialect;
 using NUnit.Framework;
+using NHibernate.Linq;
 
 namespace NHibernate.Test.CompositeId
 {
@@ -296,5 +298,15 @@ public async Task QueryAsync()
 			await (t.CommitAsync());
 			s.Close();
 		}
+
+		[Test(Description = "GH-2646")]
+		public async Task AnyOnCompositeIdAsync()
+		{
+			using (var s = OpenSession())
+			{
+				await (s.Query<Order>().Where(o => o.LineItems.Any()).ToListAsync());
+				await (s.Query<Order>().Select(o => o.LineItems.Any()).ToListAsync());
+			}
+		}
 	}
 }

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

@@ -35,6 +35,18 @@ public async Task CanExecuteAnyWithArgumentsAsync()
 			Assert.IsFalse(result);
 		}
 
+		[Test]
+		public async Task CanExecuteContainsAsync()
+		{
+			var user = await (db.Users.FirstOrDefaultAsync());
+			var result = db.Users.Contains(user);
+			Assert.That(result, Is.True);
+
+			user = new User("test", DateTime.Now);
+			result = db.Users.Contains(user);
+			Assert.That(result, Is.False);
+		}
+
 		[Test]
 		public async Task CanExecuteCountWithOrderByArgumentsAsync()
 		{
@@ -163,4 +175,4 @@ public async Task CanSelectPropertiesIntoNestedObjectArraysAsync()
 			Assert.That(nestedNestedObjectArray[1], Is.EqualTo("ayende"));
 		}
 	}
-}
+}

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

@@ -616,6 +616,64 @@ public async Task UsingParameterInEvaluatableExpressionAsync()
 			await (db.Users.Where(x => names.Length == 0 || names.Contains(x.Name)).ToListAsync());
 		}
 
+		[Test]
+		public async Task UsingParameterWithImplicitOperatorAsync()
+		{
+			var id = new GuidImplicitWrapper(new Guid("{356E4A7E-B027-4321-BA40-E2677E6502CF}"));
+			Assert.That(await (db.Shippers.Where(o => o.Reference == id).ToListAsync()), Has.Count.EqualTo(1));
+
+			id = new GuidImplicitWrapper(new Guid("{356E4A7E-B027-4321-BA40-E2677E6502FF}"));
+			Assert.That(await (db.Shippers.Where(o => o.Reference == id).ToListAsync()), Is.Empty);
+
+			await (AssertTotalParametersAsync(
+				db.Shippers.Where(o => o.Reference == id && id == o.Reference),
+				1));
+		}
+
+		private struct GuidImplicitWrapper
+		{
+			public readonly Guid Id;
+
+			public GuidImplicitWrapper(Guid id)
+			{
+				Id = id;
+			}
+
+			public static implicit operator Guid(GuidImplicitWrapper idWrapper)
+			{
+				return idWrapper.Id;
+			}
+		}
+
+		[Test]
+		public async Task UsingParameterWithExplicitOperatorAsync()
+		{
+			var id = new GuidExplicitWrapper(new Guid("{356E4A7E-B027-4321-BA40-E2677E6502CF}"));
+			Assert.That(await (db.Shippers.Where(o => o.Reference == (Guid) id).ToListAsync()), Has.Count.EqualTo(1));
+
+			id = new GuidExplicitWrapper(new Guid("{356E4A7E-B027-4321-BA40-E2677E6502FF}"));
+			Assert.That(await (db.Shippers.Where(o => o.Reference == (Guid) id).ToListAsync()), Is.Empty);
+
+			await (AssertTotalParametersAsync(
+				db.Shippers.Where(o => o.Reference == (Guid) id && (Guid) id == o.Reference),
+				1));
+		}
+
+		private struct GuidExplicitWrapper
+		{
+			public readonly Guid Id;
+
+			public GuidExplicitWrapper(Guid id)
+			{
+				Id = id;
+			}
+
+			public static explicit operator Guid(GuidExplicitWrapper idWrapper)
+			{
+				return idWrapper.Id;
+			}
+		}
+
 		[Test]
 		public async Task UsingParameterOnSelectorsAsync()
 		{

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

@@ -848,6 +848,27 @@ public async Task ContainsOnPersistedCollectionAsync()
 			Assert.That(result.SerialNumber, Is.EqualTo("1121"));
 		}
 
+		[Test]
+		public async Task CanCompareAggregateResultAsync()
+		{
+			if (!Dialect.SupportsScalarSubSelects)
+			{
+				Assert.Ignore(Dialect.GetType().Name + " does not support scalar sub-queries");
+			}
+
+			await (session.Query<Customer>()
+			       .Select(o => new AggregateDate { Id = o.CustomerId, MaxDate = o.Orders.Max(l => l.RequiredOrderDate)})
+			       .Where(o => o.MaxDate <= DateTime.Today && o.MaxDate >= DateTime.Today)
+			       .ToListAsync());
+		}
+
+		private class AggregateDate
+		{
+			public string Id { get; set; }
+
+			public DateTime? MaxDate { get; set; }
+		}
+
 		private static List<object[]> CanUseCompareInQueryDataSource()
 		{
 			return new List<object[]>

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

@@ -0,0 +1,57 @@
+//------------------------------------------------------------------------------
+// <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 NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH2608
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class FixtureAsync : BugTestCase
+	{
+		protected override void OnTearDown()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				session.CreateQuery("delete from PersonalDetails").ExecuteUpdate();
+				session.CreateQuery("delete from System.Object").ExecuteUpdate();
+
+				transaction.Commit();
+			}
+		}
+
+		[Test]
+		public async Task MergeBidiPrimaryKeyOneToOneAsync()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var p = new Person { Name = "steve" };
+				p.Details = new PersonalDetails { SomePersonalDetail = "I have big feet", Person = p };
+				await (s.MergeAsync(p));
+				await (tx.CommitAsync());
+			}
+		}
+
+		[Test]
+		public async Task PersistBidiPrimaryKeyOneToOneAsync()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				var p = new Person { Name = "steve" };
+				p.Details = new PersonalDetails { SomePersonalDetail = "I have big feet", Person = p };
+				await (s.PersistAsync(p));
+				await (tx.CommitAsync());
+			}
+		}
+	}
+}