Merge 5.4.1 into master

Author: fredericDelaporte

doc/reference/modules/basic_mapping.xml

@@ -2385,6 +2385,7 @@
                     <area id="onetoone9" coords="10 60"/>
                     <area id="onetoone10" coords="11 60"/>
                     <area id="onetoone11" coords="12 60"/>
+                    <area id="onetoone12" coords="13 60"/>
                 </areaspec>
                 <programlisting><![CDATA[<one-to-one
     name="propertyName"
@@ -2398,6 +2399,7 @@
     formula="any SQL expression"
     entity-name="entityName"
     foreign-key="foreignKeyName"
+    optimistic-lock="true|false"
 />]]></programlisting>
                 <calloutlist>
                     <callout arearefs="onetoone1">
@@ -2471,12 +2473,20 @@
                             <literal>entity-name</literal> (optional): The entity name of the associated class.
                         </para>
                     </callout>
-                    <callout arearefs="manytoone11">
+                    <callout arearefs="onetoone11">
                         <para>
                             <literal>foreign-key</literal> (optional): Specifies the name of the foreign key
                             constraint for DDL generation.
                         </para>
                     </callout>
+                    <callout arearefs="onetoone12">
+                        <para>
+                            <literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>):
+                            Specifies that updates to this property do or do not require acquisition of the
+                            optimistic lock. In other words, determines if a version increment should occur when
+                            this property is dirty.
+                        </para>
+                    </callout>
                 </calloutlist>
             </programlistingco>
 

doc/reference/modules/configuration.xml

@@ -1728,7 +1728,7 @@ in the parameter binding.</programlisting>
                                     Use the assembly qualified class name of a custom <literal>IObjectsFactory</literal>
                                     implementation.
                                 </para>
-                                <programlisting><![CDATA[<bytecode-provider
+                                <programlisting><![CDATA[<objects-factory
     type="className" />]]></programlisting>
                                 <para>
                                     You can also set this property by code by setting

releasenotes.txt

@@ -1,4 +1,25 @@
-Build 5.4.0
+Build 5.4.1
+=============================
+
+Release notes - NHibernate - Version 5.4.1
+
+4 issues were resolved in this release.
+
+** Bug
+
+   * #3216 Enable one-to-one optimistic lock handling in mapping
+   * #3215 Count(Distinct ...) does not work
+   * #3203 Fix a wrong example in configuration documentation
+
+** Task
+
+   * #3232 Release 5.4.1
+
+As part of releasing 5.4.1, a missing 5.4.0 possible breaking change has been added, about
+one-to-one associations and optimistic locking. See 5.4.0 possible breaking changes.
+
+
+Build 5.4.0
 =============================
 
 Release notes - NHibernate - Version 5.4.0
@@ -12,6 +33,8 @@ Release notes - NHibernate - Version 5.4.0
     * 201 issues were resolved in this release.
 
     ##### Possible Breaking Changes #####
+        * One-to-one changes does now trigger a version increment, consistently with the default behavior of other kinds of
+          associations. See #3204.
         * Linq and criteria queries on unmapped entities will throw instead of returning an empty result list. See #1106, #1095.
         * The second level cache UpdateTimestampsCache does not use locks anymore. This may slightly increase the number of cases
           where stale data is returned by the query cache. See #2742.
@@ -186,6 +209,24 @@ Release notes - NHibernate - Version 5.4.0
    * #2242 Test case for NH-3972 - SQL error when selecting a column of a subclass when sibling classes have a column of the same name
 
 
+Build 5.3.15
+=============================
+
+Release notes - NHibernate - Version 5.3.15
+
+4 issues were resolved in this release.
+
+** Bug
+
+   * #3218 Failure of contains subquery with parameter
+   * #3187 Fix mixing implied implicit and left joins in HQL for v5.3
+
+** Task
+
+   * #3225 Release 5.3.15
+   * #3222 Automatically generate async code on pull requests for 5.3
+
+
 Build 5.3.14
 =============================
 
@@ -195,8 +236,8 @@ Release notes - NHibernate - Version 5.3.14
 
 ** Bug
 
-    #3169 InvalidOperationException: This transformer is not initialized by Cached Query
-    #3164 Fetching a lazy loaded component regression
+   * #3169 InvalidOperationException: This transformer is not initialized by Cached Query
+   * #3164 Fetching a lazy loaded component regression
 
 ** Task
 
@@ -212,14 +253,14 @@ Release notes - NHibernate - Version 5.3.13
 
 ** Bug
 
-    #3134 ManyToMany - Tries to select not existing column in Mapping Table
-    #3113 Join fails on Oracle9Dialect
-    #3030 Memory leak named parameter holds entity references
+   * #3134 ManyToMany - Tries to select not existing column in Mapping Table
+   * #3113 Join fails on Oracle9Dialect
+   * #3030 Memory leak named parameter holds entity references
 
 ** Improvement
 
-    #3120 Guards against use of a disposed session factory
-    #2994 Npgsql 6 is not compatible
+   * #3120 Guards against use of a disposed session factory
+   * #2994 Npgsql 6 is not compatible
 
 ** Task
 

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

@@ -359,13 +359,17 @@ from x2 in session.Query<NullableOwner>()
 				var withNullOrValidList = await (session.Query<NullableOwner>().Where(x => x.ManyToOne.Id == validManyToOne.Id || x.ManyToOne == null).ToListAsync());
 				var withNullOrValidList2 = await (session.Query<NullableOwner>().Where(x =>  x.ManyToOne == null || x.ManyToOne.Id == validManyToOne.Id).ToListAsync());
 
+				//GH-3185
+				var mixImplicitAndLeftJoinList = await (session.Query<NullableOwner>().Where(x => x.ManyToOne.Id == validManyToOne.Id && x.OneToOne == null).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));
 				Assert.That(withNullOrValidList.Count, Is.EqualTo(2));
 				Assert.That(withNullOrValidList2.Count, Is.EqualTo(2));
+				Assert.That(mixImplicitAndLeftJoinList.Count, Is.EqualTo(1));
 			}
 		}
 

src/NHibernate.Test/Async/NHSpecificTest/GH3204/OneToOneOptimisticLockFixture.cs

@@ -0,0 +1,113 @@
+//------------------------------------------------------------------------------
+// <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;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH3204
+{
+	using System.Threading.Tasks;
+	[TestFixture(true)]
+	[TestFixture(false)]
+	[TestFixture(null)]
+	public class OneToOneOptimisticLockFixtureAsync : TestCaseMappingByCode
+	{
+		private readonly bool? _optimisticLock;
+		private Guid _id;
+
+		public OneToOneOptimisticLockFixtureAsync(bool? optimisticLock)
+		{
+			_optimisticLock = optimisticLock;
+		}
+
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+			mapper.Class<Entity>(
+				rc =>
+				{
+					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
+					rc.Property(x => x.Name);
+					rc.Version(x => x.Version, m => { });
+					rc.OneToOne(
+						x => x.OneToOne,
+						m =>
+						{
+							m.PropertyReference(x => x.Parent);
+							m.ForeignKey("none");
+							m.Cascade(Mapping.ByCode.Cascade.All);
+							if (_optimisticLock.HasValue)
+								m.OptimisticLock(_optimisticLock.Value);
+						});
+				});
+
+			mapper.Class<Child>(
+				rc =>
+				{
+					rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
+					rc.Property(x => x.Name);
+					rc.ManyToOne(
+						x => x.Parent,
+						m =>
+						{
+							m.Unique(true);
+							m.ForeignKey("none");
+						});
+				});
+
+			return mapper.CompileMappingForAllExplicitlyAddedEntities();
+		}
+
+		protected override void OnSetUp()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var e1 = new Entity { Name = "Bob" };
+				session.Save(e1);
+				transaction.Commit();
+				_id = e1.Id;
+			}
+		}
+
+		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 GetAsync()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var result = await (session.GetAsync<Entity>(_id));
+
+				var child = new Child() { Parent = result };
+				result.OneToOne = child;
+				var oldVersion = result.Version;
+				await (transaction.CommitAsync());
+				session.Clear();
+
+				Assert.That(
+					(await (session.GetAsync<Entity>(_id))).Version,
+					Is.EqualTo(_optimisticLock.GetValueOrDefault(true) ? oldVersion + 1 : oldVersion));
+			}
+		}
+	}
+}

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

@@ -0,0 +1,64 @@
+//------------------------------------------------------------------------------
+// <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 NHibernate.Cfg;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH3215
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class ByCodeFixtureAsync : TestCaseMappingByCode
+	{
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+
+			mapper.Class<Member>(rc =>
+			{
+				rc.Id(x => x.Code);
+				rc.Property(x => x.Name);
+				rc.Property(x => x.Date);
+			});
+
+			mapper.Class<Request>(rc =>
+			{
+				rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
+				rc.ManyToOne(x => x.Member);
+			});
+			return mapper.CompileMappingForAllExplicitlyAddedEntities();
+		}
+
+		protected override bool AppliesTo(Dialect.Dialect dialect)
+		{
+			return TestDialect.SupportsCountDistinct;
+		}
+
+		protected override void Configure(Configuration configuration)
+		{
+			base.Configure(configuration);
+			configuration.SetProperty(Environment.Hbm2ddlKeyWords, "auto-quote");
+		}
+
+		[Test]
+		public async Task CountDistinctWithReservedWordsAsync()
+		{
+			using (var session = OpenSession())
+			{
+				var hql = "select  Count(DISTINCT r.Member.id), Count(DISTINCT Date(r.Member.Date)) from Request r";
+				var result = await (session.CreateQuery(hql).ListAsync());
+
+				Assert.That(result, Has.Count.EqualTo(1));
+			}
+		}
+	}
+}