Enable one-to-one optimistic lock handling in mapping

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>
 

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/NHSpecificTest/GH3204/Entity.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace NHibernate.Test.NHSpecificTest.GH3204
+{
+	public class Entity
+	{
+		public virtual Guid Id { get; set; }
+		public virtual string Name { get; set; }
+		public virtual int Version { get; set; }
+		public virtual Child OneToOne { get; set; }
+	}
+
+	public class Child
+	{
+		public virtual Guid Id { get; set; }
+		public virtual string Name { get; set; }
+		public virtual Entity Parent { get; set; }
+	}
+}

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

@@ -0,0 +1,102 @@
+using System;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH3204
+{
+	[TestFixture(true)]
+	[TestFixture(false)]
+	[TestFixture(null)]
+	public class OneToOneOptimisticLockFixture : TestCaseMappingByCode
+	{
+		private readonly bool? _optimisticLock;
+		private Guid _id;
+
+		public OneToOneOptimisticLockFixture(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 void Get()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var result = session.Get<Entity>(_id);
+
+				var child = new Child() { Parent = result };
+				result.OneToOne = child;
+				var oldVersion = result.Version;
+				transaction.Commit();
+				session.Clear();
+
+				Assert.That(
+					session.Get<Entity>(_id).Version,
+					Is.EqualTo(_optimisticLock.GetValueOrDefault(true) ? oldVersion + 1 : oldVersion));
+			}
+		}
+	}
+}

src/NHibernate/Cfg/MappingSchema/Hbm.generated.cs

@@ -2922,6 +2922,11 @@ public partial class HbmOneToOne {
         [System.ComponentModel.DefaultValueAttribute(false)]
         public bool constrained;
 
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute("optimistic-lock")]
+        [System.ComponentModel.DefaultValueAttribute(true)]
+        public bool optimisticlock;
+
         /// <remarks/>
         [System.Xml.Serialization.XmlAttributeAttribute("foreign-key")]
         public string foreignkey;
@@ -2944,6 +2949,7 @@ public partial class HbmOneToOne {
 
         public HbmOneToOne() {
             this.constrained = false;
+            this.optimisticlock = true;
         }
     }
 

src/NHibernate/Cfg/MappingSchema/HbmOneToOne.cs

@@ -20,7 +20,8 @@ public string Access
 
 		public bool OptimisticLock
 		{
-			get { return true; }
+			get => optimisticlock;
+			set => optimisticlock = value;
 		}
 
 		#endregion	

src/NHibernate/Mapping/ByCode/Impl/OneToOneMapper.cs

@@ -55,7 +55,7 @@ public void Access(System.Type accessorType)
 
 		public void OptimisticLock(bool takeInConsiderationForOptimisticLock)
 		{
-			// not supported by HbmOneToOne
+			_oneToOne.optimisticlock = takeInConsiderationForOptimisticLock;
 		}
 
 		#endregion

src/NHibernate/nhibernate-mapping.xsd

@@ -1040,6 +1040,7 @@
 			</xs:attribute>
 			<xs:attribute name="constrained" default="false" type="xs:boolean">
 			</xs:attribute>
+			<xs:attribute name="optimistic-lock" default="true" type="xs:boolean" />
 			<xs:attribute name="foreign-key" type="xs:string" />
 			<xs:attribute name="property-ref" type="xs:string" />
 			<xs:attribute name="lazy" type="laziness">