Merge branch 'master' into WIP_groupJoin

Author: bahusoid

releasenotes.txt

@@ -1,4 +1,36 @@
-Build 5.3.2
+Build 5.3.3
+=============================
+
+Release notes - NHibernate - Version 5.3.3
+
+16 issues were resolved in this release.
+
+** Bug
+
+   * #2519 Fix parameter caching for Linq provider
+   * #2515 InvalidCastException for Linq query with subquery
+   * #2514 Entity with field interceptor are not correctly passed as Linq parameters
+   * #2512 Linq queries with a condition after a projection on a collection fail
+   * #2511 Linq Fetch over component after fetching a many-to-one throws exception
+   * #2508 OnPreUpdateCollection - Passed entity instance X is not of expected type Y
+   * #2499 Cast operation fails when an enum is mapped as an AnsiString
+   * #2490 Unnecessary cast in sql with Linq are causing performance issues
+   * #2488 Fix parameter detection for Equals and CompareTo methods for Linq provider
+   * #2485 Throw entity not mapped exception for entity join in hql if possible
+   * #2484 Entity Joins are not polymorphic in hql
+   * #2476 Hashset add returns true instead of false
+   * #2474 Fetch all lazy properties when entity is already loaded fails
+   * #2471 AsQueryable() on collection throws if applied after Where statement
+
+** Task
+
+   * #2482 Add missing possible breaking changes for #2010
+   * #2527 Release 5.3.3
+
+As part of releasing 5.3.3, two missing 5.3.0 possible breaking changes have been added, about
+uninitialized extra lazy collections and SQLite schema validation. See 5.3.0 possible breaking changes.
+
+Build 5.3.2
 =============================
 
 Release notes - NHibernate - Version 5.3.2
@@ -69,12 +101,40 @@ Release notes - NHibernate - Version 5.3.0
           stored as `REAL` instead of `NUMERIC`. Both are binary floating point types, excepted that `NUMERIC`
           stores integral values as `INTEGER`. This change may cause big integral decimal values to lose more
           precision in SQLite.
+        * SQLite: non supported SQL type names previously used by NHibernate, resulting in unexpected actual typing,
+          have been fixed. This causes databases generated by a previous NHibernate version to fail schema validation
+          by 5.3 or higher versions. See #2507 for more information.
         * Custom dialects used for databases that do not support cross join will have to override
           `SupportsCrossJoin` property and set it to `false`.
         * `VisitorParameters.ConstantToParameterMap` may contain the same parameter for multiple constant
           expressions.
         * `ICache` caches yielded by the session factory will be `CacheBase` wrappers around the cache actually
           provided by the cache provider, if it was not deriving from `CacheBase`.
+        * Calling `IList.RemoveAt` or `IList<>.RemoveAt` on an uninitialized list with a negative number
+          will now throw an `ArgumentOutOfRangeException`.
+        * Calling `IList.RemoveAt` or `IList<>.RemoveAt` on an uninitialized list mapped as `lazy="extra"`
+          with a number that is equal or higher that the current collection size will now throw an
+          `ArgumentOutOfRangeException`.
+        * Calling `IList.Insert` or `IList<>.Insert` on an uninitialized list with a negative number will
+          now throw an `ArgumentOutOfRangeException`.
+        * Calling `IList.Insert` or `IList<>.Insert` on an uninitialized list mapped as `lazy="extra"`
+          with a number that is higher that the current collection size will now throw an 
+          `ArgumentOutOfRangeException`.
+        * Getting or setting a value with `IList.this[int index]` or `IList<>.this[int index]` on an uninitialized
+          list with a negative number will now throw an `ArgumentOutOfRangeException`.
+        * Setting a value with `IList.this[int index]` or `IList<>.this[int index]` on an uninitialized list
+          mapped as `lazy="extra"` with a number that is equal or higher that the current collection size will now
+          throw an `ArgumentOutOfRangeException`.
+        * Calling `IDictionary<,>.Add` or `ICollection<>.Add` on an uninitialized map mapped as `lazy="extra"` with
+          a key that already exists will now throw an `ArgumentException`.
+        * Calling `IDictionary<,>.Remove` or `ICollection<>.Remove` on an uninitialized map mapped as `lazy="extra"`
+          with a key that does not exist will now return false.
+        * Map dirtiness is now evaluated by `EqualityComparer<TValue>.Default` when setting an existing key value
+          with `IDictionary<,>.this[]` on an initialized map.
+        * Calling `ISet<>.Add` on an uninitialized set mapped as `lazy="extra"` with a transient element that
+          already exists in the set will now return false.
+        * Calling `ISet<>.Add` or `ICollection<>.Add` on an uninitialized set mapped as `lazy="true"` with a
+          transient element that does not override `Equals` method will not initialize the collection.
 
 ** Bug
 

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

@@ -22,6 +22,8 @@ public class AnotherEntityRequired
 
 		public virtual ISet<AnotherEntity> RelatedItems { get; set; } = new HashSet<AnotherEntity>();
 
+		public virtual ISet<AnotherEntityRequired> RequiredRelatedItems { get; set; } = new HashSet<AnotherEntityRequired>();
+
 		public virtual bool? NullableBool { get; set; }
 	}
 

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

@@ -69,6 +69,11 @@ public IQueryable<User> Users
             get { return _session.Query<User>(); }
         }
 
+        public IQueryable<NumericEntity> NumericEntities
+        {
+            get { return _session.Query<NumericEntity>(); }
+        }
+
         public IQueryable<DynamicUser> DynamicUsers
         {
             get { return _session.Query<DynamicUser>(); }

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

@@ -0,0 +1,29 @@
+namespace NHibernate.DomainModel.Northwind.Entities
+{
+	public class NumericEntity
+	{
+		public virtual short Short { get; set; }
+
+		public virtual short? NullableShort { get; set; }
+
+		public virtual int Integer { get; set; }
+
+		public virtual int? NullableInteger { get; set; }
+
+		public virtual long Long { get; set; }
+
+		public virtual long? NullableLong { get; set; }
+
+		public virtual decimal Decimal { get; set; }
+
+		public virtual decimal? NullableDecimal { get; set; }
+
+		public virtual float Single { get; set; }
+
+		public virtual float? NullableSingle { get; set; }
+
+		public virtual double Double { get; set; }
+
+		public virtual double? NullableDouble { get; set; }
+	}
+}

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

@@ -19,5 +19,9 @@
       <key column="Id"/>
       <one-to-many class="AnotherEntity"/>
     </set>
+    <set name="RequiredRelatedItems" lazy="true" inverse="true">
+      <key column="Id"/>
+      <one-to-many class="AnotherEntityRequired"/>
+    </set>
   </class>
 </hibernate-mapping>

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

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" namespace="NHibernate.DomainModel.Northwind.Entities" assembly="NHibernate.DomainModel">
+  <class name="NumericEntity">
+    <id name="Short">
+      <generator class="assigned" />
+    </id>
+
+    <property name="NullableShort" />
+    <property name="Integer" not-null="true" column="`Integer`" />
+    <property name="NullableInteger" />
+    <property name="Long" not-null="true" column="`Long`" />
+    <property name="NullableLong" />
+    <property name="Decimal" not-null="true" column="`Decimal`" />
+    <property name="NullableDecimal" />
+    <property name="Single" not-null="true" column="`Single`" />
+    <property name="NullableSingle" />
+    <property name="Double" not-null="true" column="`Double`" />
+    <property name="NullableDouble" />
+  </class>
+</hibernate-mapping>

src/NHibernate.Test/Async/Extralazy/ExtraLazyFixture.cs

@@ -1326,6 +1326,52 @@ public async Task SetAddAsync(bool initialize)
 			}
 		}
 
+		[Test]
+		public async Task SetAddWithOverrideEqualsAsync()
+		{
+			User gavin;
+			User robert;
+			User tom;
+
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				gavin = new User("gavin", "secret");
+				robert = new User("robert", "secret");
+				tom = new User("tom", "secret");
+				await (s.PersistAsync(gavin));
+				await (s.PersistAsync(robert));
+				await (s.PersistAsync(tom));
+
+				gavin.Followers.Add(new UserFollower(gavin, robert));
+				gavin.Followers.Add(new UserFollower(gavin, tom));
+				robert.Followers.Add(new UserFollower(robert, tom));
+
+				Assert.That(gavin.Followers.Count, Is.EqualTo(2), "Gavin's documents count after adding 2");
+				Assert.That(robert.Followers.Count, Is.EqualTo(1), "Robert's followers count after adding one");
+
+				await (t.CommitAsync());
+			}
+
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				gavin = await (s.GetAsync<User>("gavin"));
+				robert = await (s.GetAsync<User>("robert"));
+				tom = await (s.GetAsync<User>("tom"));
+
+				// Re-add
+				Assert.That(gavin.Followers.Add(new UserFollower(gavin, robert)), Is.False, "Re-adding element");
+				Assert.That(NHibernateUtil.IsInitialized(gavin.Followers), Is.True, "Documents initialization status after re-adding");
+				Assert.That(gavin.Followers, Has.Count.EqualTo(2), "Gavin's followers count after re-adding");
+
+				// Add new
+				Assert.That(robert.Followers.Add(new UserFollower(robert, gavin)), Is.True, "Adding element");
+				Assert.That(NHibernateUtil.IsInitialized(gavin.Followers), Is.True, "Documents initialization status after adding");
+				Assert.That(gavin.Followers, Has.Count.EqualTo(2), "Robert's followers count after re-adding");
+			}
+		}
+
 		[TestCase(false, false)]
 		[TestCase(false, true)]
 		[TestCase(true, false)]

src/NHibernate.Test/Async/FetchLazyProperties/FetchLazyPropertiesFixture.cs

@@ -666,6 +666,40 @@ private static void AssertFetchComponentManyToOne(Person person)
 
 		#endregion
 
+		#region TestHqlFetchManyToOneAndComponentManyToOne
+
+		[Test]
+		public async Task TestHqlFetchManyToOneAndComponentManyToOneAsync()
+		{
+			Person person;
+			using (var s = OpenSession())
+			{
+				person = await (s.CreateQuery("from Person p fetch p.Address left join fetch p.Address.Continent left join fetch p.BestFriend where p.Id = 1").UniqueResultAsync<Person>());
+			}
+
+			AssertFetchManyToOneAndComponentManyToOne(person);
+		}
+
+		[Test]
+		public async Task TestLinqFetchManyToOneAndComponentManyToOneAsync()
+		{
+			Person person;
+			using (var s = OpenSession())
+			{
+				person = await (s.Query<Person>().Fetch(o => o.BestFriend).Fetch(o => o.Address).ThenFetch(o => o.Continent).FirstOrDefaultAsync(o => o.Id == 1));
+			}
+
+			AssertFetchManyToOneAndComponentManyToOne(person);
+		}
+
+		private static void AssertFetchManyToOneAndComponentManyToOne(Person person)
+		{
+			AssertFetchComponentManyToOne(person);
+			Assert.That(NHibernateUtil.IsInitialized(person.BestFriend), Is.True);
+		}
+
+		#endregion
+
 		#region FetchSubClassFormula
 
 		[Test]
@@ -945,6 +979,26 @@ public async Task TestFetchAfterEntityIsInitializedAsync(bool readOnly)
 			Assert.That(NHibernateUtil.IsPropertyInitialized(person, "Formula"), Is.True);
 		}
 
+		[TestCase(true)]
+		[TestCase(false)]
+		public async Task TestFetchAllPropertiesAfterEntityIsInitializedAsync(bool readOnly)
+		{
+			Person person;
+			using(var s = OpenSession())
+			using(var tx = s.BeginTransaction())
+			{
+				person = await (s.CreateQuery("from Person where Id = 1").SetReadOnly(readOnly).UniqueResultAsync<Person>());
+				var image = person.Image;
+				person = await (s.CreateQuery("from Person fetch all properties where Id = 1").SetReadOnly(readOnly).UniqueResultAsync<Person>());
+
+				await (tx.CommitAsync());
+			}
+
+			Assert.That(NHibernateUtil.IsPropertyInitialized(person, "Image"), Is.True);
+			Assert.That(NHibernateUtil.IsPropertyInitialized(person, "Address"), Is.True);
+			Assert.That(NHibernateUtil.IsPropertyInitialized(person, "Formula"), Is.True);
+		}
+
 		[Test]
 		public async Task TestHqlCrossJoinFetchFormulaAsync()
 		{

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

@@ -140,5 +140,13 @@ from o2 in db.Orders.Where(x => x.Freight > 50)
 				Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(useCrossJoin ? 0 : 1));
 			}
 		}
+
+		[Test]
+		public async Task CanJoinOnEntityWithSubclassesAsync()
+		{
+			var result = await ((from o in db.Animals
+						from o2 in db.Animals.Where(x => x.BodyWeight > 50)
+						select new {o, o2}).Take(1).ToListAsync());
+		}
 	}
 }

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

@@ -22,6 +22,7 @@
 namespace NHibernate.Test.Linq
 {
 	using System.Threading.Tasks;
+	using System.Threading;
 	// Mainly adapted from tests contributed by Nicola Tuveri on NH-2500 (NH-2500.patch file)
 	[TestFixture]
 	public class ConstantTestAsync : LinqTestCase
@@ -118,6 +119,29 @@ public async Task ConstantNonCachedInMemberInitExpressionAsync()
 			Assert.That(s2, Has.All.Property("Name").EqualTo("shipper2"), "s2 Names");
 		}
 
+		[Test]
+		public async Task ConstantNonCachedInMemberInitExpressionWithConditionAsync()
+		{
+			var shipper1 = await (GetShipperAsync(1));
+			var shipper2 = await (GetShipperAsync(2));
+
+			Assert.That(shipper1.Number, Is.EqualTo(1));
+			Assert.That(shipper2.Number, Is.EqualTo(2));
+		}
+
+		private Task<ShipperDto> GetShipperAsync(int id, CancellationToken cancellationToken = default(CancellationToken))
+		{
+			try
+			{
+				return db.Shippers.Where(o => o.ShipperId == id)
+				         .Select(o => new ShipperDto {Number = id, CompanyName = o.CompanyName}).SingleAsync(cancellationToken);
+			}
+			catch (System.Exception ex)
+			{
+				return Task.FromException<ShipperDto>(ex);
+			}
+		}
+
 		[Test]
 		public async Task ConstantInNewArrayExpressionAsync()
 		{