HHH-11585 - Batch ordering fails for bidirectional one-to-one associations

- take into consideration legacy one-to-one mappings with composite ids as well

hibernate-core/src/main/java/org/hibernate/engine/spi/ActionQueue.java

@@ -49,6 +49,8 @@ import org.hibernate.proxy.HibernateProxy;
 import org.hibernate.proxy.LazyInitializer;
 import org.hibernate.type.CollectionType;
 import org.hibernate.type.EntityType;
+import org.hibernate.type.ForeignKeyDirection;
+import org.hibernate.type.OneToOneType;
 import org.hibernate.type.Type;
 
 /**
@@ -1146,7 +1148,8 @@ public class ActionQueue {
 						EntityType entityType = (EntityType) type;
 						String entityName = entityType.getName();
 
-						if ( entityType.isOneToOne() ) {
+						if ( entityType.isOneToOne() &&
+								OneToOneType.class.cast( entityType ).getForeignKeyDirection() == ForeignKeyDirection.TO_PARENT ) {
 							batchIdentifier.getChildEntityNames().add( entityName );
 						}
 						else {

hibernate-core/src/test/java/org/hibernate/test/insertordering/InsertOrderingWithBidirectionalMapsIdOneToOne.java

@@ -0,0 +1,116 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.test.insertordering;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.Map;
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.MapsId;
+import javax.persistence.OneToOne;
+import javax.persistence.SequenceGenerator;
+
+import org.hibernate.cfg.Environment;
+
+import org.hibernate.testing.TestForIssue;
+import org.hibernate.testing.junit4.BaseNonConfigCoreFunctionalTestCase;
+import org.hibernate.test.util.jdbc.PreparedStatementSpyConnectionProvider;
+import org.junit.Test;
+
+import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+/**
+ * @author Vlad Mihalcea
+ */
+@TestForIssue(jiraKey = "HHH-9864")
+public class InsertOrderingWithBidirectionalMapsIdOneToOne
+		extends BaseNonConfigCoreFunctionalTestCase {
+
+	private PreparedStatementSpyConnectionProvider connectionProvider = new PreparedStatementSpyConnectionProvider();
+
+	@Override
+	protected Class[] getAnnotatedClasses() {
+		return new Class[] { Address.class, Person.class };
+	}
+
+	@Override
+	protected void addSettings(Map settings) {
+		settings.put( Environment.ORDER_INSERTS, "true" );
+		settings.put( Environment.STATEMENT_BATCH_SIZE, "10" );
+		settings.put(
+				org.hibernate.cfg.AvailableSettings.CONNECTION_PROVIDER,
+				connectionProvider
+		);
+	}
+
+	@Override
+	public void releaseResources() {
+		super.releaseResources();
+		connectionProvider.stop();
+	}
+
+	@Test
+	public void testBatching() throws SQLException {
+		doInHibernate( this::sessionFactory, session -> {
+			Person worker = new Person();
+			Person homestay = new Person();
+
+			Address home = new Address();
+			Address office = new Address();
+
+			home.addPerson( homestay );
+
+			office.addPerson( worker );
+
+			session.persist( home );
+			session.persist( office );
+
+			connectionProvider.clear();
+		} );
+
+		PreparedStatement addressPreparedStatement = connectionProvider.getPreparedStatement(
+				"insert into Address (ID) values (?)" );
+		verify( addressPreparedStatement, times( 2 ) ).addBatch();
+		PreparedStatement personPreparedStatement = connectionProvider.getPreparedStatement(
+				"insert into Person (address_ID) values (?)" );
+		verify( personPreparedStatement, times( 2 ) ).addBatch();
+	}
+
+	@Entity(name = "Address")
+	public static class Address {
+		@Id
+		@Column(name = "ID", nullable = false)
+		@SequenceGenerator(name = "ID", sequenceName = "ADDRESS_SEQ")
+		@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ID")
+		private Long id;
+
+		@OneToOne(mappedBy = "address", cascade = CascadeType.PERSIST)
+		private Person person;
+
+		public void addPerson(Person person) {
+			this.person = person;
+			person.address = this;
+		}
+	}
+
+	@Entity(name = "Person")
+	public static class Person {
+		@Id
+		private Long id;
+
+		@OneToOne
+		@MapsId
+		private Address address;
+	}
+}

hibernate-core/src/test/java/org/hibernate/test/legacy/FumTest.java

@@ -40,6 +40,8 @@ import org.hibernate.LockMode;
 import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.Transaction;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.cfg.Environment;
 import org.hibernate.criterion.MatchMode;
 import org.hibernate.criterion.Restrictions;
 import org.hibernate.dialect.AbstractHANADialect;
@@ -90,6 +92,15 @@ public class FumTest extends LegacyTestCase {
 		};
 	}
 
+	@Override
+	public void configure(Configuration cfg) {
+		super.configure(cfg);
+		Properties props = new Properties();
+		props.put( Environment.ORDER_INSERTS, "true" );
+		props.put( Environment.STATEMENT_BATCH_SIZE, "10" );
+		cfg.addProperties( props );
+	}
+
 	@Test
 	public void testQuery() {
 		Session s = openSession();