HHH-19739 Construct property for OneToOne early to allow field deduplication

Author: beikov

hibernate-core/src/main/java/org/hibernate/boot/model/internal/ClassPropertyHolder.java

@@ -224,6 +224,19 @@ public void addProperty(Property prop, XClass declaringClass) {
 		}
 	}
 
+	@Override
+	public void movePropertyToJoin(Property property, Join join, XClass declaringClass) {
+		if ( property.getValue() instanceof Component ) {
+			//TODO handle quote and non quote table comparison
+			final String tableName = property.getValue().getTable().getName();
+			if ( getJoinsPerRealTableName().get( tableName ) == join ) {
+				// Skip moving the property, since it was already added to the join
+				return;
+			}
+		}
+		persistentClass.movePropertyToJoin( property, join );
+	}
+
 	@Override
 	public Join addJoin(JoinTable joinTableAnn, boolean noDelayInPkColumnCreation) {
 		Join join = entityBinder.addJoin( joinTableAnn, this, noDelayInPkColumnCreation );

hibernate-core/src/main/java/org/hibernate/boot/model/internal/CollectionPropertyHolder.java

@@ -286,6 +286,11 @@ public void addProperty(Property prop, XClass declaringClass) {
 		throw new AssertionFailure( "Cannot add property to a collection" );
 	}
 
+	@Override
+	public void movePropertyToJoin(Property prop, Join join, XClass declaringClass) {
+		throw new AssertionFailure( "Cannot add property to a collection" );
+	}
+
 	@Override
 	public KeyValue getIdentifier() {
 		throw new AssertionFailure( "Identifier collection not yet managed" );

hibernate-core/src/main/java/org/hibernate/boot/model/internal/ComponentPropertyHolder.java

@@ -306,6 +306,16 @@ public void addProperty(Property prop, XClass declaringClass) {
 		component.addProperty( prop );
 	}
 
+	@Override
+	public void movePropertyToJoin(Property prop, Join join, XClass declaringClass) {
+		// or maybe only throw if component.getTable() != join.getTable()
+		throw new AnnotationException(
+				"Embeddable class '" + component.getComponentClassName()
+				+ "' has an unowned @OneToOne property " + prop.getName()
+				+ "mapped to a join table which is unsupported"
+		);
+	}
+
 	@Override
 	public KeyValue getIdentifier() {
 		return component.getOwner().getIdentifier();

hibernate-core/src/main/java/org/hibernate/boot/model/internal/OneToOneSecondPass.java

@@ -10,11 +10,7 @@
 
 import org.hibernate.AnnotationException;
 import org.hibernate.MappingException;
-import org.hibernate.annotations.LazyGroup;
 import org.hibernate.annotations.NotFoundAction;
-import org.hibernate.annotations.OnDeleteAction;
-import org.hibernate.annotations.common.reflection.XClass;
-import org.hibernate.annotations.common.reflection.XProperty;
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.boot.spi.PropertyData;
 import org.hibernate.boot.spi.SecondPass;
@@ -28,131 +24,87 @@
 import org.hibernate.mapping.PersistentClass;
 import org.hibernate.mapping.Property;
 import org.hibernate.mapping.SortableValue;
-import org.hibernate.type.ForeignKeyDirection;
-
-import jakarta.persistence.ForeignKey;
+import org.hibernate.mapping.Value;
 
 import static org.hibernate.boot.model.internal.BinderHelper.checkMappedByType;
 import static org.hibernate.boot.model.internal.BinderHelper.findPropertyByName;
 import static org.hibernate.boot.model.internal.BinderHelper.getPath;
-import static org.hibernate.boot.model.internal.ToOneBinder.bindForeignKeyNameAndDefinition;
-import static org.hibernate.boot.model.internal.ToOneBinder.defineFetchingStrategy;
-import static org.hibernate.boot.model.internal.ToOneBinder.getReferenceEntityName;
 import static org.hibernate.internal.util.StringHelper.qualify;
-import static org.hibernate.type.ForeignKeyDirection.FROM_PARENT;
-import static org.hibernate.type.ForeignKeyDirection.TO_PARENT;
 
 /**
  * We have to handle {@link jakarta.persistence.OneToOne} associations
  * in a second pass.
  */
 public class OneToOneSecondPass implements SecondPass {
 	private final MetadataBuildingContext buildingContext;
+	private final OneToOne oneToOne;
+	private final PropertyBinder binder;
+	private final Property property;
 	private final String mappedBy;
 	private final String ownerEntity;
 	private final PropertyHolder propertyHolder;
-	private final NotFoundAction notFoundAction;
 	private final PropertyData inferredData;
-	private final XClass targetEntity;
-	private final OnDeleteAction onDeleteAction;
-	private final boolean optional;
-	private final String cascadeStrategy;
+	private final NotFoundAction notFoundAction;
 	private final AnnotatedJoinColumns joinColumns;
+	private final boolean annotatedEntity;
 
 	public OneToOneSecondPass(
+			PropertyBinder binder,
+			Property property,
+			OneToOne oneToOne,
 			String mappedBy,
 			String ownerEntity,
-			@SuppressWarnings("unused") String ownerProperty,
 			PropertyHolder propertyHolder,
 			PropertyData inferredData,
-			XClass targetEntity,
+			boolean annotatedEntity,
 			NotFoundAction notFoundAction,
-			OnDeleteAction onDeleteAction,
-			boolean optional,
-			String cascadeStrategy,
 			AnnotatedJoinColumns columns,
 			MetadataBuildingContext buildingContext) {
+		this.binder = binder;
+		this.property = property;
+		this.oneToOne = oneToOne;
 		this.ownerEntity = ownerEntity;
 		this.mappedBy = mappedBy;
 		this.propertyHolder = propertyHolder;
 		this.buildingContext = buildingContext;
 		this.notFoundAction = notFoundAction;
 		this.inferredData = inferredData;
-		this.targetEntity = targetEntity;
-		this.onDeleteAction = onDeleteAction;
-		this.optional = optional;
-		this.cascadeStrategy = cascadeStrategy;
+		this.annotatedEntity = annotatedEntity;
 		this.joinColumns = columns;
 	}
 
 	@Override
 	public void doSecondPass(Map<String, PersistentClass> persistentClasses) throws MappingException {
-		final OneToOne value = new OneToOne(
-				buildingContext,
-				propertyHolder.getTable(),
-				propertyHolder.getPersistentClass()
-		);
-		final String propertyName = inferredData.getPropertyName();
-		value.setPropertyName( propertyName );
-		final String referencedEntityName = getReferenceEntityName( inferredData, targetEntity, buildingContext );
-		value.setReferencedEntityName( referencedEntityName );
-		XProperty property = inferredData.getProperty();
-		defineFetchingStrategy( value, property, inferredData, propertyHolder );
-		//value.setFetchMode( fetchMode );
-		value.setOnDeleteAction( onDeleteAction );
-		//value.setLazy( fetchMode != FetchMode.JOIN );
-
-		value.setConstrained( !optional );
-		value.setForeignKeyType( getForeignKeyDirection() );
-		bindForeignKeyNameAndDefinition( value, property, property.getAnnotation( ForeignKey.class ), buildingContext );
-
-		final PropertyBinder binder = new PropertyBinder();
-		binder.setName( propertyName );
-		binder.setProperty( property );
-		binder.setValue( value );
-		binder.setCascade( cascadeStrategy );
-		binder.setAccessType( inferredData.getDefaultAccess() );
-		binder.setBuildingContext( buildingContext );
-
-		final LazyGroup lazyGroupAnnotation = property.getAnnotation( LazyGroup.class );
-		if ( lazyGroupAnnotation != null ) {
-			binder.setLazyGroup( lazyGroupAnnotation.value() );
-		}
-
-		final Property result = binder.makeProperty();
-		result.setOptional( optional );
 		if ( mappedBy == null ) {
-			bindOwned( persistentClasses, value, propertyName, result );
+			bindOwned( persistentClasses, oneToOne, inferredData.getPropertyName() );
 		}
 		else {
-			bindUnowned( persistentClasses, value, result );
+			bindUnowned( persistentClasses, oneToOne );
 		}
-		value.sortProperties();
+		oneToOne.sortProperties();
 	}
 
-	private ForeignKeyDirection getForeignKeyDirection() {
-		return mappedBy == null ? FROM_PARENT : TO_PARENT;
-	}
-
-	private void bindUnowned(Map<String, PersistentClass> persistentClasses, OneToOne oneToOne, Property property) {
+	private void bindUnowned(Map<String, PersistentClass> persistentClasses, OneToOne oneToOne) {
 		oneToOne.setMappedByProperty( mappedBy );
-		final PersistentClass targetEntity = persistentClasses.get( oneToOne.getReferencedEntityName() );
+		final String targetEntityName = oneToOne.getReferencedEntityName();
+		final PersistentClass targetEntity = persistentClasses.get( targetEntityName );
 		if ( targetEntity == null ) {
+			final String problem = annotatedEntity
+					? " which does not belong to the same persistence unit"
+					: " which is not an '@Entity' type";
 			throw new MappingException( "Association '" + getPath( propertyHolder, inferredData )
-					+ "' targets unknown entity type '" + oneToOne.getReferencedEntityName() + "'" );
+										+ "' targets the type '" + targetEntityName + "'" + problem );
 		}
 		final Property targetProperty = targetProperty( oneToOne, targetEntity );
-		if ( targetProperty.getValue() instanceof OneToOne ) {
-			propertyHolder.addProperty( property, inferredData.getDeclaringClass() );
-		}
-		else if ( targetProperty.getValue() instanceof ManyToOne ) {
-			bindTargetManyToOne( persistentClasses, oneToOne, property, targetEntity, targetProperty );
+		final Value targetPropertyValue = targetProperty.getValue();
+		if ( targetPropertyValue instanceof ManyToOne ) {
+			bindTargetManyToOne( persistentClasses, oneToOne, targetEntity, targetProperty );
 		}
-		else {
+		else if ( !(targetPropertyValue instanceof OneToOne) ) {
 			throw new AnnotationException( "Association '" + getPath( propertyHolder, inferredData )
-					+ "' is 'mappedBy' a property named '" + mappedBy
-					+ "' of the target entity type '" + oneToOne.getReferencedEntityName()
-					+ "' which is not a '@OneToOne' or '@ManyToOne' association" );
+										   + "' is 'mappedBy' a property named '" + mappedBy
+										   + "' of the target entity type '" + targetEntityName
+										   + "' which is not a '@OneToOne' or '@ManyToOne' association" );
 		}
 		checkMappedByType(
 				mappedBy,
@@ -166,7 +118,6 @@ else if ( targetProperty.getValue() instanceof ManyToOne ) {
 	private void bindTargetManyToOne(
 			Map<String, PersistentClass> persistentClasses,
 			OneToOne oneToOne,
-			Property property,
 			PersistentClass targetEntity,
 			Property targetProperty) {
 		Join otherSideJoin = null;
@@ -196,10 +147,9 @@ private void bindTargetManyToOne(
 				copy.setValue( manyToOne );
 				manyToOne.addColumn( copy );
 			}
-			mappedByJoin.addProperty( property );
-		}
-		else {
-			propertyHolder.addProperty( property, inferredData.getDeclaringClass() );
+			// The property was added to the propertyHolder eagerly to have knowledge about this property,
+			// in order for de-duplication to kick in, but we move it to a join if necessary
+			propertyHolder.movePropertyToJoin( property, mappedByJoin, inferredData.getDeclaringClass() );
 		}
 
 		oneToOne.setReferencedPropertyName( mappedBy );
@@ -235,7 +185,7 @@ private Property targetProperty(OneToOne oneToOne, PersistentClass targetEntity)
 				+ "' which does not exist in the target entity type '" + oneToOne.getReferencedEntityName() + "'" );
 	}
 
-	private void bindOwned(Map<String, PersistentClass> persistentClasses, OneToOne oneToOne, String propertyName, Property property) {
+	private void bindOwned(Map<String, PersistentClass> persistentClasses, OneToOne oneToOne, String propertyName) {
 		final ToOneFkSecondPass secondPass = new ToOneFkSecondPass(
 				oneToOne,
 				joinColumns,
@@ -246,7 +196,6 @@ private void bindOwned(Map<String, PersistentClass> persistentClasses, OneToOne
 		);
 		secondPass.doSecondPass(persistentClasses);
 		//no column associated since it's a one to one
-		propertyHolder.addProperty( property, inferredData.getDeclaringClass() );
 	}
 
 	/**

hibernate-core/src/main/java/org/hibernate/boot/model/internal/PropertyHolder.java

@@ -37,6 +37,8 @@ public interface PropertyHolder {
 
 	void addProperty(Property prop, AnnotatedColumns columns, XClass declaringClass);
 
+	void movePropertyToJoin(Property prop, Join join, XClass declaringClass);
+
 	KeyValue getIdentifier();
 
 	/**