HHH-15045 avoid dirty-flush for OneToOne type

hibernate-core/src/main/java/org/hibernate/type/EntityType.java

@@ -385,7 +385,7 @@ public boolean isEqual(Object x, Object y, SessionFactoryImplementor factory) {
 	/**
 	 * Resolve an identifier or unique key value
 	 */
-	private Object resolve(Object value, SharedSessionContractImplementor session, Object owner) {
+	protected Object resolve(Object value, SharedSessionContractImplementor session, Object owner) {
 		if ( value != null && !isNull( owner, session ) ) {
 			if ( isReferenceToPrimaryKey() ) {
 				return resolveIdentifier( value, session, null );

hibernate-core/src/main/java/org/hibernate/type/OneToOneType.java

@@ -106,17 +106,12 @@ public boolean isOneToOne() {
 
 	@Override
 	public boolean isDirty(Object old, Object current, SharedSessionContractImplementor session) {
-		if ( isSame( old, current ) ) {
-			return false;
-		}
-
-		return getIdentifierType( session )
-				.isDirty( getIdentifier( old, session ), getIdentifier( current, session ), session );
+		return false;
 	}
 
 	@Override
 	public boolean isDirty(Object old, Object current, boolean[] checkable, SharedSessionContractImplementor session) {
-		return isDirty(old, current, session);
+		return false;
 	}
 
 	@Override
@@ -159,6 +154,12 @@ public Serializable disassemble(Object value, SharedSessionContractImplementor s
 
 	@Override
 	public Object assemble(Serializable oid, SharedSessionContractImplementor session, Object owner) throws HibernateException {
+		if ( oid == null ) {
+			if ( uniqueKeyPropertyName != null ) {
+				return resolve( session.getContextEntityIdentifier( owner ), session, owner );
+			}
+			return null;
+		}
 
 		//the owner of the association is not the owner of the id
 		Object id = getIdentifierType( session ).assemble( oid, session, null );
@@ -169,9 +170,14 @@ public Object assemble(Serializable oid, SharedSessionContractImplementor sessio
 
 		return resolveIdentifier( id, session );
 	}
-
+
+	/**
+	 * We don't need to dirty check one-to-one because of how
+	 * assemble/disassemble is implemented and because a one-to-one
+	 * association is never dirty
+	 */
 	@Override
 	public boolean isAlwaysDirtyChecked() {
-		return true;
+		return false;
 	}
 }

hibernate-core/src/test/java/org/hibernate/orm/test/onetoone/flush/DirtyFlushTest.java

@@ -0,0 +1,100 @@
+package org.hibernate.orm.test.onetoone.flush;
+
+import org.hibernate.cfg.AvailableSettings;
+
+import org.hibernate.testing.TestForIssue;
+import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
+import org.hibernate.testing.orm.junit.Jpa;
+import org.hibernate.testing.orm.junit.Setting;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Version;
+
+/**
+ * @author Nathan Xu
+ */
+@TestForIssue( jiraKey = "HHH-15045" )
+@Jpa(
+	annotatedClasses = {
+		DirtyFlushTest.User.class,
+		DirtyFlushTest.Profile.class
+	},
+	properties = @Setting(name = AvailableSettings.GLOBALLY_QUOTED_IDENTIFIERS, value = "true")
+)
+class DirtyFlushTest {
+
+	@BeforeEach
+	void setUp(EntityManagerFactoryScope scope) {
+		scope.inTransaction( em -> {
+			final User user = new User();
+			user.id = 1;
+			user.version = 1;
+
+			final Profile profile = new Profile();
+			profile.id = 1;
+			profile.version = 1;
+
+			em.persist( user );
+			em.persist( profile );
+		} );
+	}
+
+	@Test
+	void testDirtyFlushNotHappened(EntityManagerFactoryScope scope) {
+		scope.inTransaction( em -> {
+			final User user = em.find( User.class, 1 );
+			final Profile profile = em.find( Profile.class, 1 );
+			profile.user = user;
+			user.profile = profile;
+
+			em.persist( profile );
+			em.flush();
+		} );
+
+		scope.inTransaction( em -> {
+			final Profile profile = em.find( Profile.class, 1 );
+			Assertions.assertEquals( 2, profile.version );
+
+			final User user = em.find( User.class, 1 );
+			Assertions.assertEquals( 1, user.version, "without fixing, the version will be bumped due to erroneous dirty flushing" );
+		} );
+	}
+
+	@AfterEach
+	void tearDown(EntityManagerFactoryScope scope) {
+		scope.inTransaction( em -> {
+			em.createQuery( "delete from Profile" ).executeUpdate();
+			em.createQuery( "delete from User" ).executeUpdate();
+		} );
+	}
+
+
+	@Entity(name = "User")
+	static class User {
+		@Id
+		int id;
+
+		@Version
+		int version;
+
+		@OneToOne(mappedBy = "user")
+		Profile profile;
+	}
+
+	@Entity(name = "Profile")
+	static class Profile {
+		@Id
+		int id;
+
+		@Version int version;
+		@OneToOne // internally Hibernate will use `@ManyToOne` for this field
+		User user;
+	}
+
+}