don't create UniqueKeys for Columns with no assigned names

Author: gavinking

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

@@ -299,7 +299,8 @@ protected void initMappingColumn(
 		else {
 			mappingColumn = new Column();
 			mappingColumn.setExplicit( !isImplicit );
-			redefineColumnName( columnName, propertyName, applyNamingStrategy );
+			final boolean nameDetermined =
+					inferColumnNameIfPossible( columnName, propertyName, applyNamingStrategy );
 			mappingColumn.setLength( length );
 			if ( precision != null && precision > 0 ) {  //relevant precision
 				mappingColumn.setPrecision( precision );
@@ -311,7 +312,12 @@ protected void initMappingColumn(
 			mappingColumn.setArrayLength( arrayLength );
 			mappingColumn.setNullable( nullable );
 			mappingColumn.setSqlType( sqlType );
-			if ( unique ) {
+			mappingColumn.setUnique( unique );
+			// if the column name is not determined, we will assign the
+			// name to the unique key later this method gets called again
+			// from linkValueUsingDefaultColumnNaming() in second pass
+			if ( unique && nameDetermined ) {
+				// assign a unique key name to the column
 				getParent().getTable().createUniqueKey( mappingColumn, getBuildingContext() );
 			}
 			for ( CheckConstraint constraint : checkConstraints ) {
@@ -341,12 +347,25 @@ public boolean isNameDeferred() {
 		return mappingColumn == null || isEmpty( mappingColumn.getName() );
 	}
 
-	public void redefineColumnName(String columnName, String propertyName, boolean applyNamingStrategy) {
+	/**
+	 * Attempt to infer the column name from the explicit {@code name} given by the annotation and the property or field
+	 * name. In the case of a {@link jakarta.persistence.JoinColumn}, this is impossible, due to the rules implemented in
+	 * {@link org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl#determineJoinColumnName}. In cases
+	 * where the column name cannot be inferred, the {@link Column} is not assigned a name, and this method returns
+	 * {@code false}. The "dummy" {@code Column} will later be replaced with a {@code Column} with a name determined by
+	 * the {@link ImplicitNamingStrategy} when {@link AnnotatedJoinColumn#linkValueUsingDefaultColumnNaming} is called
+	 * during a {@link org.hibernate.boot.spi.SecondPass}.
+	 * @return {@code true} if a name could be inferred
+	 */
+	boolean inferColumnNameIfPossible(String columnName, String propertyName, boolean applyNamingStrategy) {
 		if ( !isEmpty( columnName ) || !isEmpty( propertyName ) ) {
 			final String logicalColumnName = resolveLogicalColumnName( columnName, propertyName );
 			mappingColumn.setName( processColumnName( logicalColumnName, applyNamingStrategy ) );
+			return true;
+		}
+		else {
+			return false;
 		}
-		// else nothing to do
 	}
 
 	private String resolveLogicalColumnName(String columnName, String propertyName) {

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

@@ -8,6 +8,7 @@
 import org.hibernate.AssertionFailure;
 import org.hibernate.annotations.JoinFormula;
 import org.hibernate.boot.model.naming.Identifier;
+import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
 import org.hibernate.boot.model.naming.ObjectNameNormalizer;
 import org.hibernate.boot.model.relational.Database;
 import org.hibernate.boot.spi.InFlightMetadataCollector;
@@ -312,6 +313,11 @@ public void copyReferencedStructureAndCreateDefaultJoinColumns(
 		setMappingColumn( null );
 	}
 
+	/**
+	 * The JPA-specified rules implemented in
+	 * {@link org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl#determineJoinColumnName}
+	 * prevent us from assigning defaulted names to {@link JoinColumn} until the second pass.
+	 */
 	public void linkValueUsingDefaultColumnNaming(
 			Column referencedColumn,
 			PersistentClass referencedEntity,
@@ -325,11 +331,15 @@ public void linkValueUsingDefaultColumnNaming(
 			Column referencedColumn,
 			PersistentClass referencedEntity,
 			SimpleValue value) {
+		// In the case of a reference to a composite primary key,
+		// this instance of AnnotatedJoinColumn actually represents
+		// multiple foreign key columns, and this method will be
+		// called multiple times on the same instance
 		final String logicalReferencedColumn =
 				getBuildingContext().getMetadataCollector()
 						.getLogicalColumnName( referencedEntity.getTable(), referencedColumn.getQuotedName() );
 		final String columnName = defaultColumnName( columnIndex, referencedEntity, logicalReferencedColumn );
-		//yuk side effect on an implicit column
+		// awful side effect on an implicit column
 		setLogicalColumnName( columnName );
 		setImplicit( true );
 		setReferencedColumn( logicalReferencedColumn );
@@ -450,10 +460,23 @@ public void overrideFromReferencedColumnIfNecessary(Column column) {
 		}
 	}
 
+	/**
+	 * Assign the column name from the explicit {@code name} given by the annotation, if any. In cases where the column
+	 * name cannot be inferred, the {@link Column} is not assigned a name, and this method returns {@code false}. The
+	 * "dummy" {@code Column} will later be replaced with a {@code Column} with name determined by the rules implemented
+	 * in {@link org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl#determineJoinColumnName},
+	 * as required by the JPA specification, or by any other custom {@link ImplicitNamingStrategy} when
+	 * {@link #linkValueUsingDefaultColumnNaming} is called during a {@link org.hibernate.boot.spi.SecondPass}.
+	 * @return {@code true} if a name could be inferred
+	 */
 	@Override
-	public void redefineColumnName(String columnName, String propertyName, boolean applyNamingStrategy) {
+	boolean inferColumnNameIfPossible(String columnName, String propertyName, boolean applyNamingStrategy) {
 		if ( isNotEmpty( columnName ) ) {
 			getMappingColumn().setName( processColumnName( columnName, applyNamingStrategy ) );
+			return true;
+		}
+		else {
+			return false;
 		}
 	}
 

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

@@ -759,12 +759,13 @@ private static void bindImplicitColumns(
 			PersistentClass referencedEntity,
 			AnnotatedJoinColumns joinColumns,
 			SimpleValue value) {
-		final KeyValue keyValue = referencedEntity instanceof JoinedSubclass
-				? referencedEntity.getKey()
-				: referencedEntity.getIdentifier();
-		final List<Column> idColumns = keyValue.getColumns();
-		for ( int i = 0; i < idColumns.size(); i++ ) {
-			final Column column = idColumns.get(i);
+		final KeyValue keyValue =
+				referencedEntity instanceof JoinedSubclass
+						? referencedEntity.getKey()  // a joined subclass is referenced via the key of the subclass table
+						: referencedEntity.getIdentifier();
+		final List<Column> referencedKeyColumns = keyValue.getColumns();
+		for ( int i = 0; i < referencedKeyColumns.size(); i++ ) {
+			final Column column = referencedKeyColumns.get(i);
 			final AnnotatedJoinColumn firstColumn = joinColumns.getJoinColumns().get(0);
 			firstColumn.linkValueUsingDefaultColumnNaming( i, column, referencedEntity, value );
 			firstColumn.overrideFromReferencedColumnIfNecessary( column );

hibernate-core/src/main/java/org/hibernate/mapping/Table.java

@@ -469,7 +469,7 @@ public Index getIndex(String indexName) {
 	}
 
 	public Index addIndex(Index index) {
-		Index current =  indexes.get( index.getName() );
+		final Index current =  indexes.get( index.getName() );
 		if ( current != null ) {
 			throw new MappingException( "Index " + index.getName() + " already exists" );
 		}
@@ -478,7 +478,7 @@ public Index addIndex(Index index) {
 	}
 
 	public UniqueKey addUniqueKey(UniqueKey uniqueKey) {
-		UniqueKey current = uniqueKeys.get( uniqueKey.getName() );
+		final UniqueKey current = uniqueKeys.get( uniqueKey.getName() );
 		if ( current != null ) {
 			throw new MappingException( "UniqueKey " + uniqueKey.getName() + " already exists" );
 		}
@@ -487,7 +487,9 @@ public UniqueKey addUniqueKey(UniqueKey uniqueKey) {
 	}
 
 	/**
-	 * Mark the given column unique.
+	 * Mark the given column unique and assign a name to the unique key.
+	 * <p>
+	 * This method does not add a {@link UniqueKey} to the table itself!
 	 */
 	public void createUniqueKey(Column column, MetadataBuildingContext context) {
 		final String keyName = context.getBuildingOptions().getImplicitNamingStrategy()