introduce AnnotatedColumns

hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/ModelBinder.java

@@ -3275,9 +3275,9 @@ protected void createBackReferences() {
 					&& !collectionBinding.isInverse()
 					&& !collectionBinding.getKey().isNullable() ) {
 				// for non-inverse one-to-many, with a not-null fk, add a backref!
-				String entityName = ( (OneToMany) collectionBinding.getElement() ).getReferencedEntityName();
+				final String entityName = ( (OneToMany) collectionBinding.getElement() ).getReferencedEntityName();
-				PersistentClass referenced = getReferencedEntityBinding( entityName );
+				final PersistentClass referenced = getReferencedEntityBinding( entityName );
-				Backref prop = new Backref();
+				final Backref prop = new Backref();
 				prop.setName( '_' + collectionBinding.getOwnerEntityName() + "." + pluralAttributeSource.getName() + "Backref" );
 				prop.setUpdateable( false );
 				prop.setSelectable( false );
@@ -3298,13 +3298,13 @@ protected void createBackReferences() {
 
 		protected void bindCollectionKey() {
 			final PluralAttributeKeySource keySource = getPluralAttributeSource().getKeySource();
-			final String propRef = keySource.getReferencedPropertyName();
+			final String referencedPropertyName = keySource.getReferencedPropertyName();
-			getCollectionBinding().setReferencedPropertyName( propRef );
+			getCollectionBinding().setReferencedPropertyName( referencedPropertyName );
 
 			final PersistentClass owner = getCollectionBinding().getOwner();
-			final KeyValue keyVal = propRef == null
+			final KeyValue keyVal = referencedPropertyName == null
 					? owner.getIdentifier()
-					: (KeyValue) owner.getRecursiveProperty( propRef ).getValue();
+					: (KeyValue) owner.getRecursiveProperty( referencedPropertyName ).getValue();
 			final DependantValue key = new DependantValue(
 					mappingDocument,
 					getCollectionBinding().getCollectionTable(),

hibernate-core/src/main/java/org/hibernate/cfg/AnnotatedColumn.java

@@ -42,6 +42,7 @@
 import static org.hibernate.cfg.BinderHelper.getRelativePath;
 import static org.hibernate.internal.util.StringHelper.isEmpty;
 import static org.hibernate.internal.util.StringHelper.isNotEmpty;
+import static org.hibernate.internal.util.StringHelper.qualify;
 
 /**
  * A mapping to a column, logically representing a
@@ -67,8 +68,9 @@ public class AnnotatedColumn {
 	private Column mappingColumn;
 	private boolean insertable = true;
 	private boolean updatable = true;
-	private String explicitTableName;
+	private String explicitTableName; // the JPA @Column annotation lets you specify a table name
 	protected Map<String, Join> joins;
+	@Deprecated // use AnnotatedColumns.propertyHolder
 	protected PropertyHolder propertyHolder;
 	private boolean isImplicit;
 	public String sqlType;
@@ -81,7 +83,6 @@ public class AnnotatedColumn {
 	private boolean nullable = true;
 	private String formulaString;
 	private Formula formula;
-	private Table table;
 	private String readExpression;
 	private String writeExpression;
 
@@ -91,8 +92,10 @@ public class AnnotatedColumn {
 	private String comment;
 	private String checkConstraint;
 
-	public void setTable(Table table) {
+	private AnnotatedColumns parent;
-		this.table = table;
+
+	void setParent(AnnotatedColumns parent) {
+		this.parent = parent;
 	}
 
 	public String getLogicalColumnName() {
@@ -123,23 +126,16 @@ public boolean isFormula() {
 		return isNotEmpty( formulaString );
 	}
 
-	@SuppressWarnings("UnusedDeclaration")
 	public String getFormulaString() {
 		return formulaString;
 	}
 
-	@SuppressWarnings("UnusedDeclaration")
 	public String getExplicitTableName() {
 		return explicitTableName;
 	}
 
 	public void setExplicitTableName(String explicitTableName) {
-		if ( "``".equals( explicitTableName ) ) {
+		this.explicitTableName = "``".equals( explicitTableName ) ? "" : explicitTableName;
-			this.explicitTableName = "";
-		}
-		else {
-			this.explicitTableName = explicitTableName;
-		}
 	}
 
 	public void setFormula(String formula) {
@@ -371,8 +367,8 @@ public AttributePath getAttributePath() {
 							public boolean isCollectionElement() {
 								// if the propertyHolder is a collection, assume the
 								// @Column refers to the element column
-								return !propertyHolder.isComponent()
+								return !getPropertyHolder().isComponent()
-									&& !propertyHolder.isEntity();
+									&& !getPropertyHolder().isEntity();
 							}
 
 							@Override
@@ -426,9 +422,10 @@ public void setJoins(Map<String, Join> joins) {
 	}
 
 	public PropertyHolder getPropertyHolder() {
-		return propertyHolder;
+		return propertyHolder; //TODO: change this to delegate to the parent
 	}
 
+	@Deprecated // use AnnotatedColumns.setPropertyHolder() instead
 	public void setPropertyHolder(PropertyHolder propertyHolder) {
 		this.propertyHolder = propertyHolder;
 	}
@@ -437,12 +434,16 @@ protected void setMappingColumn(Column mappingColumn) {
 		this.mappingColumn = mappingColumn;
 	}
 
+	//TODO: move this operation to AnnotatedColumns!!
 	public void linkWithValue(SimpleValue value) {
 		if ( formula != null ) {
 			value.addFormula( formula );
 		}
 		else {
-			table = value.getTable();
+			final Table table = value.getTable();
+			if ( parent != null ) {
+				parent.setTableInternal( table );
+			}
 			getMappingColumn().setValue( value );
 			value.addColumn( getMappingColumn(), insertable, updatable );
 			table.addColumn( getMappingColumn() );
@@ -494,31 +495,25 @@ public MetadataBuildingContext getBuildingContext() {
 	 * @throws AnnotationException missing secondary table
 	 */
 	public Table getTable() {
-		if ( table != null ) {
+		return parent.getTable();
-			return table;
-		}
-		else if ( isSecondary() ) {
-			return getJoin().getTable();
-		}
-		else {
-			return propertyHolder.getTable();
-		}
 	}
 
+	//TODO: move to AnnotatedColumns
 	public boolean isSecondary() {
 		if ( propertyHolder == null ) {
-			throw new AssertionFailure( "Should not call getTable() on column w/o persistent class defined" );
+			throw new AssertionFailure( "Should not call isSecondary() on column w/o persistent class defined" );
 		}
-
 		return isNotEmpty( explicitTableName )
-			&& !propertyHolder.getTable().getName().equals( explicitTableName );
+			&& !getPropertyHolder().getTable().getName().equals( explicitTableName );
 	}
 
+	//TODO: move to AnnotatedColumns
 	public Join getJoin() {
 		Join join = joins.get( explicitTableName );
 		if ( join == null ) {
 			// annotation binding seems to use logical and physical naming somewhat inconsistently...
-			final String physicalTableName = getBuildingContext().getMetadataCollector().getPhysicalTableName( explicitTableName );
+			final String physicalTableName = getBuildingContext().getMetadataCollector()
+					.getPhysicalTableName( explicitTableName );
 			if ( physicalTableName != null ) {
 				join = joins.get( physicalTableName );
 			}
@@ -526,7 +521,7 @@ public Join getJoin() {
 
 		if ( join == null ) {
 			throw new AnnotationException(
-					"Secondary table '" + explicitTableName + "' for property '" + propertyHolder.getClassName()
+					"Secondary table '" + explicitTableName + "' for property '" + getPropertyHolder().getClassName()
 					+ "' is not declared (use '@SecondaryTable' to declare the secondary table)"
 			);
 		}
@@ -544,7 +539,7 @@ public void forceNotNull() {
 		mappingColumn.setNullable( false );
 	}
 
-	public static AnnotatedColumn[] buildFormulaFromAnnotation(
+	public static AnnotatedColumns buildFormulaFromAnnotation(
 			org.hibernate.annotations.Formula formulaAnn,
 			Comment commentAnn,
 			Nullability nullability,
@@ -564,7 +559,7 @@ public static AnnotatedColumn[] buildFormulaFromAnnotation(
 		);
 	}
 
-	public static AnnotatedColumn[] buildColumnFromNoAnnotation(
+	public static AnnotatedColumns buildColumnFromNoAnnotation(
 			Comment commentAnn,
 			Nullability nullability,
 			PropertyHolder propertyHolder,
@@ -582,7 +577,7 @@ public static AnnotatedColumn[] buildColumnFromNoAnnotation(
 		);
 	}
 
-	public static AnnotatedColumn[] buildColumnFromAnnotation(
+	public static AnnotatedColumns buildColumnFromAnnotation(
 			jakarta.persistence.Column column,
 			Comment commentAnn,
 			Nullability nullability,
@@ -602,7 +597,7 @@ public static AnnotatedColumn[] buildColumnFromAnnotation(
 		);
 	}
 
-	public static AnnotatedColumn[] buildColumnsFromAnnotations(
+	public static AnnotatedColumns buildColumnsFromAnnotations(
 			jakarta.persistence.Column[] columns,
 			Comment commentAnn,
 			Nullability nullability,
@@ -623,7 +618,7 @@ public static AnnotatedColumn[] buildColumnsFromAnnotations(
 		);
 	}
 
-	public static AnnotatedColumn[] buildColumnsFromAnnotations(
+	public static AnnotatedColumns buildColumnsFromAnnotations(
 			jakarta.persistence.Column[] columns,
 			Comment commentAnn,
 			Nullability nullability,
@@ -645,7 +640,7 @@ public static AnnotatedColumn[] buildColumnsFromAnnotations(
 		);
 	}
 
-	public static AnnotatedColumn[] buildColumnOrFormulaFromAnnotation(
+	public static AnnotatedColumns buildColumnOrFormulaFromAnnotation(
 			jakarta.persistence.Column column,
 			org.hibernate.annotations.Formula formulaAnn,
 			Comment commentAnn,
@@ -667,7 +662,7 @@ public static AnnotatedColumn[] buildColumnOrFormulaFromAnnotation(
 		);
 	}
 
-	public static AnnotatedColumn[] buildColumnsOrFormulaFromAnnotation(
+	public static AnnotatedColumns buildColumnsOrFormulaFromAnnotation(
 			jakarta.persistence.Column[] columns,
 			org.hibernate.annotations.Formula formulaAnn,
 			Comment comment,
@@ -685,10 +680,13 @@ public static AnnotatedColumn[] buildColumnsOrFormulaFromAnnotation(
 			formulaColumn.setBuildingContext( context );
 			formulaColumn.setPropertyHolder( propertyHolder );
 			formulaColumn.bind();
-			return new AnnotatedColumn[] { formulaColumn };
+			final AnnotatedColumns result = new AnnotatedColumns();
+			result.setPropertyHolder( propertyHolder );
+			result.setColumns(new AnnotatedColumn[] {formulaColumn});
+			return result;
 		}
 		else {
-			jakarta.persistence.Column[]  actualCols = overrideColumns( columns, propertyHolder, inferredData);
+			final jakarta.persistence.Column[]  actualCols = overrideColumns( columns, propertyHolder, inferredData );
 			if ( actualCols == null ) {
 				return buildImplicitColumn(
 						inferredData,
@@ -719,7 +717,7 @@ private static jakarta.persistence.Column[] overrideColumns(
 			PropertyHolder propertyHolder,
 			PropertyData inferredData ) {
 		final jakarta.persistence.Column[] overriddenCols = propertyHolder.getOverriddenColumn(
-				StringHelper.qualify( propertyHolder.getPath(), inferredData.getPropertyName() )
+				qualify( propertyHolder.getPath(), inferredData.getPropertyName() )
 		);
 		if ( overriddenCols != null ) {
 			//check for overridden first
@@ -739,7 +737,7 @@ private static jakarta.persistence.Column[] overrideColumns(
 		}
 	}
 
-	private static AnnotatedColumn[] buildExplicitColumns(
+	private static AnnotatedColumns buildExplicitColumns(
 			Comment comment,
 			PropertyHolder propertyHolder,
 			PropertyData inferredData,
@@ -775,7 +773,10 @@ private static AnnotatedColumn[] buildExplicitColumns(
 					tableName
 			);
 		}
-		return columns;
+		final AnnotatedColumns result = new AnnotatedColumns();
+		result.setPropertyHolder(propertyHolder);
+		result.setColumns(columns);
+		return result;
 	}
 
 	private static AnnotatedColumn buildColumn(
@@ -884,8 +885,8 @@ private void extractDataFromPropertyData(PropertyData inferredData) {
 		if ( inferredData != null ) {
 			XProperty property = inferredData.getProperty();
 			if ( property != null ) {
-				if ( propertyHolder.isComponent() ) {
+				if ( getPropertyHolder().isComponent() ) {
-					processColumnTransformerExpressions( propertyHolder.getOverriddenColumnTransformer( logicalColumnName ) );
+					processColumnTransformerExpressions( getPropertyHolder().getOverriddenColumnTransformer( logicalColumnName ) );
 				}
 				processColumnTransformerExpressions( property.getAnnotation( ColumnTransformer.class ) );
 				ColumnTransformers annotations = property.getAnnotation( ColumnTransformers.class );
@@ -909,7 +910,7 @@ private void processColumnTransformerExpressions(ColumnTransformer annotation) {
 		}
 	}
 
-	private static AnnotatedColumn[] buildImplicitColumn(
+	private static AnnotatedColumns buildImplicitColumn(
 			PropertyData inferredData,
 			String suffixForDefaultColumnName,
 			Map<String, Join> secondaryTables,
@@ -917,8 +918,9 @@ private static AnnotatedColumn[] buildImplicitColumn(
 			Comment comment,
 			Nullability nullability,
 			MetadataBuildingContext context) {
-		final AnnotatedColumn[] columns = new AnnotatedColumn[1];
+		final AnnotatedColumns result = new AnnotatedColumns();
-		columns[0] = bindImplicitColumn(
+		result.setPropertyHolder( propertyHolder );
+		final AnnotatedColumn column = bindImplicitColumn(
 				inferredData,
 				suffixForDefaultColumnName,
 				secondaryTables,
@@ -927,7 +929,8 @@ private static AnnotatedColumn[] buildImplicitColumn(
 				nullability,
 				context
 		);
-		return columns;
+		result.setColumns( new AnnotatedColumn[] { column } );
+		return result;
 	}
 
 	private static AnnotatedColumn bindImplicitColumn(
@@ -968,9 +971,8 @@ private static AnnotatedColumn bindImplicitColumn(
 	}
 
 	public static void checkPropertyConsistency(AnnotatedColumn[] columns, String propertyName) {
-		int nbrOfColumns = columns.length;
+		if ( columns.length > 1 ) {
-		if ( nbrOfColumns > 1 ) {
+			for (int currentIndex = 1; currentIndex < columns.length; currentIndex++) {
-			for (int currentIndex = 1; currentIndex < nbrOfColumns; currentIndex++) {
 				if ( !columns[currentIndex].isFormula() && !columns[currentIndex - 1].isFormula() ) {
 					if ( columns[currentIndex].isNullable() != columns[currentIndex - 1].isNullable() ) {
 						throw new AnnotationException(

hibernate-core/src/main/java/org/hibernate/cfg/AnnotatedColumns.java

@@ -0,0 +1,68 @@
+package org.hibernate.cfg;
+
+import org.hibernate.mapping.Table;
+
+/**
+ * A list of columns that are mapped to a single Java property
+ * or field. This is a slightly uncomfortable abstraction here,
+ * because this concept is arguably missing from JPA (where
+ * there's no equivalent of the Hibernate-defined
+ * {@link org.hibernate.annotations.Columns} annotation) and
+ * so JPA lets each {@link jakarta.persistence.Column} specify
+ * its own {@link jakarta.persistence.Column#table table}.
+ * That leaves us having to enforce the requirement that every
+ * column mapped to a given property must belong to the same
+ * table.
+ *
+ * @author Gavin King
+ */
+public class AnnotatedColumns {
+    private AnnotatedColumn[] columns;
+    private Table table;
+    private PropertyHolder propertyHolder;
+
+    public void setColumns(AnnotatedColumn[] columns) {
+        this.columns = columns;
+        if ( columns != null ) {
+            for ( AnnotatedColumn column : columns ) {
+                column.setParent( this );
+            }
+        }
+    }
+
+    public AnnotatedColumn[] getColumns() {
+        return columns;
+    }
+
+    public PropertyHolder getPropertyHolder() {
+        return propertyHolder;
+    }
+
+    public void setPropertyHolder(PropertyHolder propertyHolder) {
+        this.propertyHolder = propertyHolder;
+    }
+
+    public Table getTable() {
+        if ( table != null ) {
+            return table;
+        }
+        else {
+            // all the columns have to be mapped to the same table
+            // even though at the annotation level it looks like
+            // they could each specify a different table
+            final AnnotatedColumn firstColumn = columns[0];
+            return firstColumn.isSecondary()
+                    ? firstColumn.getJoin().getTable()
+                    : firstColumn.getPropertyHolder().getTable();
+        }
+    }
+
+    public void setTable(Table table) {
+        this.table = table;
+    }
+
+    @Deprecated
+    void setTableInternal(Table table) {
+        this.table = table;
+    }
+}

hibernate-core/src/main/java/org/hibernate/cfg/AnnotatedJoinColumn.java

@@ -549,6 +549,7 @@ public String toString() {
 	}
 
 	public void setParent(AnnotatedJoinColumns parent) {
+		super.setParent( parent );
 		this.parent = parent;
 	}
 }

hibernate-core/src/main/java/org/hibernate/cfg/AnnotatedJoinColumns.java

@@ -45,7 +45,7 @@
  *
  * @author Gavin King
  */
-public class AnnotatedJoinColumns {
+public class AnnotatedJoinColumns extends AnnotatedColumns {
 
     private AnnotatedJoinColumn[] columns;
     private PropertyHolder propertyHolder;
@@ -60,8 +60,6 @@ public class AnnotatedJoinColumns {
     private boolean elementCollection;
     private String manyToManyOwnerSideEntityName;
 
-    public AnnotatedJoinColumns() {}
-
     public static AnnotatedJoinColumns buildJoinColumnsOrFormulas(
             JoinColumnOrFormula[] joinColumnOrFormulas,
             String mappedBy,
@@ -204,7 +202,13 @@ public AnnotatedJoinColumn[] getColumns() {
         return columns;
     }
 
+    @Override
+    public void setColumns(AnnotatedColumn[] columns) {
+        throw new UnsupportedOperationException( "wrong sort of columns" );
+    }
+
     public void setColumns(AnnotatedJoinColumn[] columns) {
+        super.setColumns( columns );
         this.columns = columns;
         if ( columns != null ) {
             for ( AnnotatedJoinColumn column : columns ) {

hibernate-core/src/main/java/org/hibernate/cfg/AnnotationBinder.java

@@ -1118,7 +1118,7 @@ private static void buildProperty(
 				entityBinder,
 				context
 		).extractMetadata();
-		AnnotatedColumn[] columns = columnsBuilder.getColumns();
+		AnnotatedColumns columns = columnsBuilder.getColumns();
 		AnnotatedJoinColumns joinColumns = columnsBuilder.getJoinColumns();
 
 		final PropertyBinder propertyBinder = new PropertyBinder();
@@ -1252,7 +1252,7 @@ private static void bindVersionProperty(
 			MetadataBuildingContext context,
 			Map<XClass, InheritanceState> inheritanceStatePerClass,
 			XProperty property,
-			AnnotatedColumn[] columns,
+			AnnotatedColumns columns,
 			PropertyBinder propertyBinder) {
 		if (isIdentifierMapper) {
 			throw new AnnotationException(
@@ -1303,7 +1303,7 @@ private static void bindVersionProperty(
 		}
 	}
 
-	private static AnnotatedColumn[] bindBasic(
+	private static AnnotatedColumns bindBasic(
 			PropertyHolder propertyHolder,
 			Nullability nullability,
 			PropertyData inferredData,
@@ -1315,14 +1315,14 @@ private static AnnotatedColumn[] bindBasic(
 			Map<XClass, InheritanceState> inheritanceStatePerClass,
 			XProperty property,
 			ColumnsBuilder columnsBuilder,
-			AnnotatedColumn[] columns,
+			AnnotatedColumns columns,
 			XClass returnedClass,
 			PropertyBinder propertyBinder) {
 
 		// overrides from @MapsId or @IdClass if needed
 		final boolean isComposite;
 		final boolean isOverridden;
-		final AnnotatedColumn[] actualColumns;
+		final AnnotatedColumns actualColumns;
 		if ( propertyBinder.isId() || propertyHolder.isOrWithinEmbeddedId() || propertyHolder.isInIdClass() ) {
 			// the associated entity could be using an @IdClass making the overridden property a component
 			final PropertyData overridingProperty = getPropertyOverriddenByMapperOrMapsId(
@@ -1450,7 +1450,7 @@ private static void createBasicBinder(
 			Nullability nullability,
 			MetadataBuildingContext context,
 			XProperty property,
-			AnnotatedColumn[] columns,
+			AnnotatedColumns columns,
 			PropertyBinder propertyBinder,
 			boolean isOverridden) {
 		//provide the basic property mapping
@@ -1469,12 +1469,12 @@ private static void createBasicBinder(
 		//implicit type will check basic types and Serializable classes
 		if ( propertyBinder.isId() || !optional && nullability != Nullability.FORCED_NULL ) {
 			//force columns to not null
-			for ( AnnotatedColumn col : columns ) {
+			for ( AnnotatedColumn column : columns.getColumns() ) {
-				if ( propertyBinder.isId() && col.isFormula() ) {
+				if ( propertyBinder.isId() && column.isFormula() ) {
 					throw new CannotForceNonNullableException( "Identifier property '"
 							+ getPath( propertyHolder, inferrredData ) + "' cannot map to a '@Formula'" );
 				}
-				col.forceNotNull();
+				column.forceNotNull();
 			}
 		}
 
@@ -1499,7 +1499,7 @@ private static PropertyBinder createCompositeBinder(
 			MetadataBuildingContext context,
 			Map<XClass, InheritanceState> inheritanceStatePerClass,
 			XProperty property,
-			AnnotatedColumn[] columns,
+			AnnotatedColumns columns,
 			XClass returnedClass,
 			PropertyBinder propertyBinder,
 			boolean isOverridden,
@@ -1509,7 +1509,7 @@ private static PropertyBinder createCompositeBinder(
 		final AnnotatedJoinColumns actualColumns;
 		if ( isOverridden ) {
 			// careful: not always a @MapsId property, sometimes it's from an @IdClass
-			PropertyData mapsIdProperty = getPropertyOverriddenByMapperOrMapsId(
+			final PropertyData mapsIdProperty = getPropertyOverriddenByMapperOrMapsId(
 					propertyBinder.isId(), propertyHolder, property.getName(), context
 			);
 			referencedEntityName = mapsIdProperty.getClassOrElementName();
@@ -1518,7 +1518,7 @@ private static PropertyBinder createCompositeBinder(
 			joinColumns.setBuildingContext( context );
 			joinColumns.setPropertyHolder( propertyHolder );
 			joinColumns.setPropertyName( getRelativePath( propertyHolder, propertyName ) );
-			joinColumns.setColumns( (AnnotatedJoinColumn[]) columns );
+			joinColumns.setColumns( (AnnotatedJoinColumn[]) columns.getColumns() );
 			actualColumns = joinColumns;
 		}
 		else {
@@ -1574,9 +1574,9 @@ private static void bindAny(
 			);
 		}
 
-		Cascade hibernateCascade = property.getAnnotation( Cascade.class );
+		final Cascade hibernateCascade = property.getAnnotation( Cascade.class );
-		OnDelete onDeleteAnn = property.getAnnotation( OnDelete.class );
+		final OnDelete onDeleteAnn = property.getAnnotation( OnDelete.class );
-		JoinTable assocTable = propertyHolder.getJoinTable(property);
+		final JoinTable assocTable = propertyHolder.getJoinTable(property);
 		if ( assocTable != null ) {
 			Join join = propertyHolder.addJoin( assocTable, false );
 			for ( AnnotatedJoinColumn joinColumn : joinColumns.getColumns() ) {
@@ -1600,7 +1600,7 @@ private static void bindAny(
 	private static void addIndexes(
 			boolean inSecondPass,
 			XProperty property,
-			AnnotatedColumn[] columns,
+			AnnotatedColumns columns,
 			AnnotatedJoinColumns joinColumns) {
 		//process indexes after everything: in second pass, many to one has to be done before indexes
 		final Index index = property.getAnnotation( Index.class );
@@ -1613,7 +1613,7 @@ private static void addIndexes(
 			}
 			else {
 				if ( columns != null ) {
-					for ( AnnotatedColumn column : columns ) {
+					for ( AnnotatedColumn column : columns.getColumns() ) {
 						column.addIndex( index, inSecondPass );
 					}
 				}
@@ -1624,7 +1624,7 @@ private static void addIndexes(
 	private static void addNaturalIds(
 			boolean inSecondPass,
 			XProperty property,
-			AnnotatedColumn[] columns,
+			AnnotatedColumns columns,
 			AnnotatedJoinColumns joinColumns) {
 		// Natural ID columns must reside in one single UniqueKey within the Table.
 		// For now, simply ensure consistent naming.
@@ -1639,7 +1639,7 @@ private static void addNaturalIds(
 				}
 			}
 			else {
-				for ( AnnotatedColumn column : columns) {
+				for ( AnnotatedColumn column : columns.getColumns() ) {
 					String keyName = "UK_" + Constraint.hashedName( column.getTable().getName() + "_NaturalID" );
 					column.addUniqueKey( keyName, inSecondPass );
 				}
@@ -2254,8 +2254,8 @@ private static void bindAny(
 		binder.setAccessType( inferredData.getDefaultAccess() );
 		binder.setCascade( cascadeStrategy );
 		Property prop = binder.makeProperty();
-		//composite FK columns are in the same table so its OK
+		//composite FK columns are in the same table, so it's OK
-		propertyHolder.addProperty( prop, columns.getColumns(), inferredData.getDeclaringClass() );
+		propertyHolder.addProperty( prop, columns, inferredData.getDeclaringClass() );
 	}
 
 	public static HashMap<String, IdentifierGeneratorDefinition> buildGenerators(

hibernate-core/src/main/java/org/hibernate/cfg/BinderHelper.java

@@ -1049,17 +1049,18 @@ public static Any buildAnyValue(
 			EntityBinder entityBinder,
 			boolean optional,
 			MetadataBuildingContext context) {
-		final XProperty xProperty = inferredData.getProperty();
+		final XProperty property = inferredData.getProperty();
-		final AnnotatedJoinColumn[] columns = keyColumns.getColumns();
 
-		final Any value = new Any( context, columns[0].getTable(), true );
+		final Any value = new Any( context, keyColumns.getTable(), true );
 		value.setLazy( lazy );
 		value.setCascadeDeleteEnabled( cascadeOnDelete );
 
 		final BasicValueBinder discriminatorValueBinder =
 				new BasicValueBinder( BasicValueBinder.Kind.ANY_DISCRIMINATOR, context );
 
-		final AnnotatedColumn[] discriminatorColumns = buildColumnOrFormulaFromAnnotation(
+		// TODO: if there can be only one discriminator column,
+		//       why are we making a whole array of them??
+		final AnnotatedColumns discriminatorColumns = buildColumnOrFormulaFromAnnotation(
 				discriminatorColumn,
 				discriminatorFormula,
 				null,
@@ -1069,17 +1070,20 @@ public static Any buildAnyValue(
 				entityBinder.getSecondaryTables(),
 				context
 		);
-		assert discriminatorColumns.length == 1;
+		assert discriminatorColumns.getColumns().length == 1;
-		discriminatorColumns[0].setTable( value.getTable() );
+
+		discriminatorColumns.setTable( value.getTable() );
 		discriminatorValueBinder.setColumns( discriminatorColumns );
 
 		discriminatorValueBinder.setReturnedClassName( inferredData.getTypeName() );
-		discriminatorValueBinder.setType( xProperty, xProperty.getType(), null, null );
+		discriminatorValueBinder.setType( property, property.getType(), null, null );
 
 		final BasicValue discriminatorDescriptor = discriminatorValueBinder.make();
 		value.setDiscriminator( discriminatorDescriptor );
 		discriminatorValueBinder.fillSimpleValue();
-		discriminatorColumns[0].linkWithValue( discriminatorDescriptor );
+		// TODO: this is nasty
+		final AnnotatedColumn firstDiscriminatorColumn = discriminatorColumns.getColumns()[0];
+		firstDiscriminatorColumn.linkWithValue( discriminatorDescriptor );
 
 		final JavaType<?> discriminatorJavaType = discriminatorDescriptor
 				.resolve()
@@ -1095,26 +1099,23 @@ public static Any buildAnyValue(
 		);
 		value.setDiscriminatorValueMappings( discriminatorValueMappings );
 
-		BasicValueBinder keyValueBinder = new BasicValueBinder( BasicValueBinder.Kind.ANY_KEY, context );
+		final BasicValueBinder keyValueBinder = new BasicValueBinder( BasicValueBinder.Kind.ANY_KEY, context );
+		final AnnotatedJoinColumn[] columns = keyColumns.getColumns();
 		assert columns.length == 1;
-		columns[0].setTable( value.getTable() );
+		keyColumns.setTable( value.getTable() );
-		keyValueBinder.setColumns(columns);
+		keyValueBinder.setColumns( keyColumns );
-
 		if ( !optional ) {
 			for ( AnnotatedJoinColumn column : columns ) {
 				column.setNullable( false );
 			}
 		}
-		keyValueBinder.setType( xProperty, xProperty.getType(), null, null );
+		keyValueBinder.setType( property, property.getType(), null, null );
 		final BasicValue keyDescriptor = keyValueBinder.make();
 		value.setKey( keyDescriptor );
 		keyValueBinder.fillSimpleValue();
-		AnnotatedColumn.checkPropertyConsistency(
+		final String path = qualify( propertyHolder.getEntityName(), inferredData.getPropertyName() );
-				columns,
+		AnnotatedColumn.checkPropertyConsistency( columns, path );
-				propertyHolder.getEntityName() + "." + inferredData.getPropertyName()
-		);
 		columns[0].linkWithValue( keyDescriptor );
-
 		return value;
 	}
 

hibernate-core/src/main/java/org/hibernate/cfg/ClassPropertyHolder.java

@@ -12,6 +12,7 @@
 import jakarta.persistence.Converts;
 import jakarta.persistence.JoinTable;
 
+import org.hibernate.AnnotationException;
 import org.hibernate.AssertionFailure;
 import org.hibernate.MappingException;
 import org.hibernate.annotations.common.reflection.XClass;
@@ -181,12 +182,23 @@ public String getEntityName() {
 		return persistentClass.getEntityName();
 	}
 
-	public void addProperty(Property prop, AnnotatedColumn[] columns, XClass declaringClass) {
+	public void addProperty(Property prop, AnnotatedColumns columns, XClass declaringClass) {
 		//Ejb3Column.checkPropertyConsistency( ); //already called earlier
-		if ( columns != null && columns[0].isSecondary() ) {
+		if ( columns != null ) {
+			final AnnotatedColumn firstColumn = columns.getColumns()[0];
+			if ( firstColumn.isSecondary() ) {
 				//TODO move the getJoin() code here?
-			final Join join = columns[0].getJoin();
+				for ( AnnotatedColumn column : columns.getColumns() ) {
-			addPropertyToJoin( prop, declaringClass, join );
+					if ( !column.isSecondary() || column.getJoin() != firstColumn.getJoin() ) {
+						//TODO: fix the error message
+						throw new AnnotationException("different columns mapped to different tables for a single property");
+					}
+				}
+				addPropertyToJoin( prop, declaringClass, firstColumn.getJoin() );
+			}
+			else {
+				addProperty( prop, declaringClass );
+			}
 		}
 		else {
 			addProperty( prop, declaringClass );

hibernate-core/src/main/java/org/hibernate/cfg/CollectionPropertyHolder.java

@@ -309,7 +309,7 @@ public String getEntityName() {
 		return collection.getOwner().getEntityName();
 	}
 
-	public void addProperty(Property prop, AnnotatedColumn[] columns, XClass declaringClass) {
+	public void addProperty(Property prop, AnnotatedColumns columns, XClass declaringClass) {
 		//Ejb3Column.checkPropertyConsistency( ); //already called earlier
 		throw new AssertionFailure( "addProperty to a join table of a collection: does it make sense?" );
 	}

hibernate-core/src/main/java/org/hibernate/cfg/ColumnsBuilder.java

@@ -52,7 +52,7 @@ class ColumnsBuilder {
 	private final PropertyData inferredData;
 	private final EntityBinder entityBinder;
 	private final MetadataBuildingContext buildingContext;
-	private AnnotatedColumn[] columns;
+	private AnnotatedColumns columns;
 	private AnnotatedJoinColumns joinColumns;
 
 	public ColumnsBuilder(
@@ -70,7 +70,7 @@ public ColumnsBuilder(
 		this.buildingContext = buildingContext;
 	}
 
-	public AnnotatedColumn[] getColumns() {
+	public AnnotatedColumns getColumns() {
 		return columns;
 	}
 
@@ -158,8 +158,8 @@ else if ( joinColumns == null && property.isAnnotationPresent( org.hibernate.ann
 
 		if ( nullability == Nullability.FORCED_NOT_NULL ) {
 			//force columns to not null
-			for (AnnotatedColumn col : columns ) {
+			for ( AnnotatedColumn column : columns.getColumns() ) {
-				col.forceNotNull();
+				column.forceNotNull();
 			}
 		}
 		return this;
@@ -291,13 +291,9 @@ else if ( property.isAnnotationPresent( JoinColumns.class ) ) {
 		}
 	}
 
-	AnnotatedColumn[] overrideColumnFromMapperOrMapsIdProperty(boolean isId) {
+	AnnotatedColumns overrideColumnFromMapperOrMapsIdProperty(boolean isId) {
-		final PropertyData overridingProperty = getPropertyOverriddenByMapperOrMapsId(
+		final PropertyData overridingProperty =
-				isId,
+				getPropertyOverriddenByMapperOrMapsId( isId, propertyHolder, property.getName(), buildingContext );
-				propertyHolder,
-				property.getName(),
-				buildingContext
-		);
 		return overridingProperty != null ? buildExplicitOrDefaultJoinColumn( overridingProperty ) : columns;
 	}
 
@@ -305,10 +301,10 @@ AnnotatedColumn[] overrideColumnFromMapperOrMapsIdProperty(boolean isId) {
 	 * Useful to override a column either by {@code @MapsId} or by {@code @IdClass}
 	 */
 	//TODO: should we introduce an AnnotatedColumns type and return that here?
-	private AnnotatedColumn[] buildExplicitOrDefaultJoinColumn(PropertyData overridingProperty) {
+	private AnnotatedColumns buildExplicitOrDefaultJoinColumn(PropertyData overridingProperty) {
 		final AnnotatedJoinColumns columns = buildExplicitJoinColumns( overridingProperty.getProperty(), overridingProperty );
 		return columns == null
-				? buildDefaultJoinColumnsForToOne( overridingProperty.getProperty(), overridingProperty ).getColumns()
+				? buildDefaultJoinColumnsForToOne( overridingProperty.getProperty(), overridingProperty )
-				: columns.getColumns();
+				: columns;
 	}
 }

hibernate-core/src/main/java/org/hibernate/cfg/ComponentPropertyHolder.java

@@ -251,12 +251,12 @@ protected AttributeConversionInfo locateAttributeConversionInfo(XProperty proper
 	@Override
 	protected AttributeConversionInfo locateAttributeConversionInfo(String path) {
 		final String embeddedPath = StringHelper.qualifyConditionally( embeddedAttributeName, path );
-		AttributeConversionInfo fromParent = parent.locateAttributeConversionInfo( embeddedPath );
+		final AttributeConversionInfo fromParent = parent.locateAttributeConversionInfo( embeddedPath );
 		if ( fromParent != null ) {
 			return fromParent;
 		}
 
-		AttributeConversionInfo fromEmbedded = attributeConversionInfoMap.get( embeddedPath );
+		final AttributeConversionInfo fromEmbedded = attributeConversionInfoMap.get( embeddedPath );
 		if ( fromEmbedded != null ) {
 			return fromEmbedded;
 		}
@@ -268,13 +268,13 @@ public String getEntityName() {
 		return component.getComponentClassName();
 	}
 
-	public void addProperty(Property prop, AnnotatedColumn[] columns, XClass declaringClass) {
+	public void addProperty(Property property, AnnotatedColumns columns, XClass declaringClass) {
 		//Ejb3Column.checkPropertyConsistency( ); //already called earlier
 		// Check table matches between the component and the columns
 		// if not, change the component table if no properties are set
 		// if a property is set already the core cannot support that
 		if ( columns != null ) {
-			Table table = columns[0].getTable();
+			final Table table = columns.getTable();
 			if ( !table.equals( component.getTable() ) ) {
 				if ( component.getPropertySpan() == 0 ) {
 					component.setTable( table );
@@ -288,12 +288,11 @@ public void addProperty(Property prop, AnnotatedColumn[] columns, XClass declari
 				}
 			}
 		}
-		addProperty( prop, declaringClass );
+		addProperty( property, declaringClass );
 	}
 
 	public Join addJoin(JoinTable joinTableAnn, boolean noDelayInPkColumnCreation) {
 		return parent.addJoin( joinTableAnn, noDelayInPkColumnCreation );
-
 	}
 
 	public String getClassName() {

hibernate-core/src/main/java/org/hibernate/cfg/IndexOrUniqueKeySecondPass.java

@@ -59,16 +59,15 @@ public IndexOrUniqueKeySecondPass(String indexName, AnnotatedColumn column, Meta
 	@Override
 	public void doSecondPass(Map<String, PersistentClass> persistentClasses) throws MappingException {
 		if ( columns != null ) {
-			for ( String column1 : columns ) {
+			for ( String columnName : columns ) {
-				addConstraintToColumn( column1 );
+				addConstraintToColumn( columnName );
 			}
 		}
 		if ( column != null ) {
-			this.table = column.getTable();
+			table = column.getTable();
 
 			final PropertyHolder propertyHolder = column.getPropertyHolder();
-
+			final String entityName = ( propertyHolder.isComponent() ) ?
-			String entityName = ( propertyHolder.isComponent() ) ?
 					propertyHolder.getPersistentClass().getEntityName() :
 					propertyHolder.getEntityName();
 
@@ -77,8 +76,7 @@ public void doSecondPass(Map<String, PersistentClass> persistentClasses) throws
 
 			if ( property.getValue() instanceof Component ) {
 				final Component component = (Component) property.getValue();
-
+				final List<Column> columns = new ArrayList<>();
-				List<Column> columns = new ArrayList<>();
 				for ( Selectable selectable: component.getSelectables() ) {
 					if ( selectable instanceof Column ) {
 						columns.add( (Column) selectable );
@@ -97,9 +95,7 @@ public void doSecondPass(Map<String, PersistentClass> persistentClasses) throws
 
 	private void addConstraintToColumn(final String columnName ) {
 		Column column = table.getColumn(
-				new Column(
+				new Column( buildingContext.getMetadataCollector().getPhysicalColumnName( table, columnName ) )
-						buildingContext.getMetadataCollector().getPhysicalColumnName( table, columnName )
-				)
 		);
 		if ( column == null ) {
 			throw new AnnotationException(
@@ -117,13 +113,13 @@ private void addConstraintToColumn(final String columnName ) {
 
 	private void addConstraintToColumns(List<Column> columns) {
 		if ( unique ) {
-			UniqueKey uniqueKey = table.getOrCreateUniqueKey( indexName );
+			final UniqueKey uniqueKey = table.getOrCreateUniqueKey( indexName );
 			for ( Column column : columns ) {
 				uniqueKey.addColumn( column );
 			}
 		}
 		else {
-			Index index = table.getOrCreateIndex( indexName );
+			final Index index = table.getOrCreateIndex( indexName );
 			for ( Column column : columns ) {
 				index.addColumn( column );
 			}

hibernate-core/src/main/java/org/hibernate/cfg/PropertyHolder.java

@@ -35,7 +35,7 @@ public interface PropertyHolder {
 
 	void addProperty(Property prop, XClass declaringClass);
 
-	void addProperty(Property prop, AnnotatedColumn[] columns, XClass declaringClass);
+	void addProperty(Property prop, AnnotatedColumns columns, XClass declaringClass);
 
 	KeyValue getIdentifier();
 

hibernate-core/src/main/java/org/hibernate/cfg/ToOneBinder.java

@@ -142,7 +142,7 @@ private static void bindManyToOne(
 			MetadataBuildingContext context) {
 		// All FK columns should be in the same table
 		final org.hibernate.mapping.ManyToOne value =
-				new org.hibernate.mapping.ManyToOne( context, joinColumns.getColumns()[0].getTable() );
+				new org.hibernate.mapping.ManyToOne( context, joinColumns.getTable() );
 		if ( unique ) {
 			// This is a @OneToOne mapped to a physical o.h.mapping.ManyToOne
 			value.markAsLogicalOneToOne();
@@ -269,7 +269,7 @@ else if (hasSpecjManyToOne) {
 			propertyBinder.setInsertable( firstColumn.isInsertable() );
 			propertyBinder.setUpdatable( firstColumn.isUpdatable() );
 		}
-		propertyBinder.setColumns( columns.getColumns() );
+		propertyBinder.setColumns( columns );
 		propertyBinder.setAccessType( inferredData.getDefaultAccess() );
 		propertyBinder.setCascade( cascadeStrategy );
 		propertyBinder.setProperty( property );

hibernate-core/src/main/java/org/hibernate/cfg/annotations/BasicValueBinder.java

@@ -55,6 +55,7 @@
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.cfg.AccessType;
 import org.hibernate.cfg.AnnotatedColumn;
+import org.hibernate.cfg.AnnotatedColumns;
 import org.hibernate.cfg.AnnotatedJoinColumn;
 import org.hibernate.cfg.AnnotatedJoinColumns;
 import org.hibernate.cfg.PkDrivenByDefaultMapsIdSecondPass;
@@ -153,7 +154,7 @@ public enum Kind {
 	private TimeZoneStorageType timeZoneStorageType;
 
 	private Table table;
-	private AnnotatedColumn[] columns;
+	private AnnotatedColumns columns;
 
 	private BasicValue basicValue;
 
@@ -274,7 +275,7 @@ public void setTable(Table table) {
 		this.table = table;
 	}
 
-	public void setColumns(AnnotatedColumn[] columns) {
+	public void setColumns(AnnotatedColumns columns) {
 		this.columns = columns;
 	}
 
@@ -1070,7 +1071,7 @@ public void setExplicitType(String explicitType) {
 	}
 
 	private void validate() {
-		AnnotatedColumn.checkPropertyConsistency( columns, propertyName );
+		AnnotatedColumn.checkPropertyConsistency( columns.getColumns(), propertyName );
 	}
 
 	public BasicValue make() {
@@ -1083,7 +1084,7 @@ public BasicValue make() {
 		LOG.debugf( "building BasicValue for %s", propertyName );
 
 		if ( table == null ) {
-			table = columns[0].getTable();
+			table = columns.getTable();
 		}
 
 		basicValue = new BasicValue( buildingContext, table );
@@ -1125,18 +1126,19 @@ public BasicValue make() {
 
 	public void linkWithValue() {
 		final InFlightMetadataCollector collector = buildingContext.getMetadataCollector();
-		if ( !collector.isInSecondPass() && columns[0].isNameDeferred() && referencedEntityName != null ) {
+		final AnnotatedColumn firstColumn = columns.getColumns()[0];
+		if ( !collector.isInSecondPass() && firstColumn.isNameDeferred() && referencedEntityName != null ) {
 			final AnnotatedJoinColumns joinColumns = new AnnotatedJoinColumns();
 			joinColumns.setBuildingContext( buildingContext );
-			joinColumns.setPropertyHolder( columns[0].getPropertyHolder() );
+			joinColumns.setPropertyHolder( firstColumn.getPropertyHolder() );
-			joinColumns.setPropertyName( columns[0].getPropertyName() );
+			joinColumns.setPropertyName( firstColumn.getPropertyName() );
-			joinColumns.setColumns( (AnnotatedJoinColumn[]) columns );
+			joinColumns.setColumns( (AnnotatedJoinColumn[]) columns.getColumns() );
 			collector.addSecondPass(
 					new PkDrivenByDefaultMapsIdSecondPass( referencedEntityName, joinColumns, basicValue )
 			);
 		}
 		else {
-			for ( AnnotatedColumn column : columns ) {
+			for ( AnnotatedColumn column : columns.getColumns() ) {
 				column.linkWithValue( basicValue );
 			}
 		}

hibernate-core/src/main/java/org/hibernate/cfg/annotations/CollectionBinder.java

@@ -100,6 +100,7 @@
 import org.hibernate.cfg.AccessType;
 import org.hibernate.cfg.AnnotatedClassType;
 import org.hibernate.cfg.AnnotatedColumn;
+import org.hibernate.cfg.AnnotatedColumns;
 import org.hibernate.cfg.AnnotatedJoinColumn;
 import org.hibernate.cfg.AnnotatedJoinColumns;
 import org.hibernate.cfg.AnnotationBinder;
@@ -173,6 +174,7 @@
 import static org.hibernate.internal.util.StringHelper.isNotEmpty;
 import static org.hibernate.internal.util.StringHelper.nullIfEmpty;
 import static org.hibernate.internal.util.StringHelper.qualify;
+import static org.hibernate.internal.util.collections.ArrayHelper.isEmpty;
 
 /**
  * Base class for binding different types of collections to Hibernate configuration objects.
@@ -216,12 +218,12 @@ public abstract class CollectionBinder {
 	protected AnnotatedJoinColumns foreignJoinColumns;
 	private AnnotatedJoinColumns joinColumns;
 	private boolean isExplicitAssociationTable;
-	private AnnotatedColumn[] elementColumns;
+	private AnnotatedColumns elementColumns;
 	protected boolean isEmbedded;
 	protected XProperty property;
 	protected NotFoundAction notFoundAction;
 	private TableBinder tableBinder;
-	protected AnnotatedColumn[] mapKeyColumns;
+	protected AnnotatedColumns mapKeyColumns;
 	protected AnnotatedJoinColumns mapKeyManyToManyColumns;
 	protected Map<String, IdentifierGeneratorDefinition> localGenerators;
 	protected Map<XClass, InheritanceState> inheritanceStatePerClass;
@@ -321,7 +323,7 @@ && isToManyAssociationWithinEmbeddableCollection( propertyHolder ) ) {
 				? inferredData
 				: new WrappedInferredData( inferredData, "element" );
 		final Comment comment = property.getAnnotation( Comment.class );
-		final AnnotatedColumn[] elementColumns = elementColumns(
+		final AnnotatedColumns elementColumns = elementColumns(
 				propertyHolder,
 				nullability,
 				entityBinder,
@@ -419,6 +421,7 @@ private static String handleTargetEntity(
 		if ( oneToManyAnn != null ) {
 			for ( AnnotatedJoinColumn column : joinColumns.getColumns() ) {
 				if ( column.isSecondary() ) {
+					//TODO: fix the error message
 					throw new NotYetImplementedException( "Collections having FK in secondary table" );
 				}
 			}
@@ -434,6 +437,7 @@ private static String handleTargetEntity(
 		else if ( elementCollectionAnn != null ) {
 			for ( AnnotatedJoinColumn column : joinColumns.getColumns() ) {
 				if ( column.isSecondary() ) {
+					//TODO: fix the error message
 					throw new NotYetImplementedException( "Collections having FK in secondary table" );
 				}
 			}
@@ -487,7 +491,7 @@ private static boolean isToManyAssociationWithinEmbeddableCollection(PropertyHol
 		}
 	}
 
-	private static AnnotatedColumn[] elementColumns(
+	private static AnnotatedColumns elementColumns(
 			PropertyHolder propertyHolder,
 			Nullability nullability,
 			EntityBinder entityBinder,
@@ -553,7 +557,7 @@ private static JoinColumn[] mapKeyColumns(
 				? new jakarta.persistence.Column[] { new MapKeyColumnDelegator( property.getAnnotation( MapKeyColumn.class ) ) }
 				: null;
 
-		final AnnotatedColumn[] mapColumns = buildColumnsFromAnnotations(
+		final AnnotatedColumns mapColumns = buildColumnsFromAnnotations(
 				keyColumns,
 				comment,
 				Nullability.FORCED_NOT_NULL,
@@ -1544,9 +1548,8 @@ protected void bindOneToManySecondPass(Map<String, PersistentClass> persistentCl
 		foreignJoinColumns.setPersistentClass( associatedClass, joins, inheritanceStatePerClass );
 		for ( AnnotatedJoinColumn column : foreignJoinColumns.getColumns() ) {
 			column.setJoins( joins );
-			//TODO: this is lame, should get the table from foreignJoinColumns
-			collection.setCollectionTable( column.getTable() );
 		}
+		collection.setCollectionTable( foreignJoinColumns.getTable() );
 		if ( LOG.isDebugEnabled() ) {
 			LOG.debugf( "Mapping collection: %s -> %s", collection.getRole(), collection.getCollectionTable().getName() );
 		}
@@ -1555,7 +1558,7 @@ protected void bindOneToManySecondPass(Map<String, PersistentClass> persistentCl
 		handleWhere( false );
 
 		final PersistentClass targetEntity = persistentClasses.get( getElementType().getName() );
-		bindCollectionSecondPass( targetEntity, foreignJoinColumns, cascadeDeleteEnabled, buildingContext );
+		bindCollectionSecondPass( targetEntity, foreignJoinColumns, cascadeDeleteEnabled );
 
 		if ( !collection.isInverse() && !collection.getKey().isNullable() ) {
 			createOneToManyBackref( oneToMany );
@@ -1838,12 +1841,11 @@ private DependantValue buildCollectionKey(
 			boolean cascadeDeleteEnabled,
 			boolean noConstraintByDefault,
 			XProperty property,
-			PropertyHolder propertyHolder,
+			PropertyHolder propertyHolder) {
-			MetadataBuildingContext buildingContext) {
 
 		// give a chance to override the referenced property name
 		// has to do that here because the referencedProperty creation happens in a FKSecondPass for ManyToOne yuk!
-		overrideReferencedPropertyName( collection, joinColumns, buildingContext );
+		overrideReferencedPropertyName( collection, joinColumns );
 
 		final String referencedPropertyName = collection.getReferencedPropertyName();
 		//binding key reference using column
@@ -1955,15 +1957,12 @@ private static void handleForeignKeyConstraint(boolean noConstraintByDefault, De
 		}
 	}
 
-	private void overrideReferencedPropertyName(
+	private void overrideReferencedPropertyName(Collection collection, AnnotatedJoinColumns joinColumns) {
-			Collection collection,
-			AnnotatedJoinColumns joinColumns,
-			MetadataBuildingContext context) {
 		if ( hasMappedBy() && joinColumns.getColumns().length > 0 ) {
 			final String entityName = joinColumns.getManyToManyOwnerSideEntityName() != null
 					? "inverse__" + joinColumns.getManyToManyOwnerSideEntityName()
 					: joinColumns.getPropertyHolder().getEntityName();
-			final InFlightMetadataCollector collector = context.getMetadataCollector();
+			final InFlightMetadataCollector collector = buildingContext.getMetadataCollector();
 			final String referencedProperty = collector.getPropertyReferencedAssociation( entityName, mappedBy );
 			if ( referencedProperty != null ) {
 				collection.setReferencedPropertyName( referencedProperty );
@@ -2021,7 +2020,7 @@ private void bindManyToManySecondPass(Map<String, PersistentClass> persistentCla
 		bindFilters( isCollectionOfEntities );
 		handleWhere( isCollectionOfEntities );
 
-		bindCollectionSecondPass( targetEntity, joinColumns, cascadeDeleteEnabled, buildingContext );
+		bindCollectionSecondPass( targetEntity, joinColumns, cascadeDeleteEnabled );
 
 		if ( isCollectionOfEntities ) {
 			final ManyToOne element = handleCollectionOfEntities(
@@ -2033,7 +2032,7 @@ private void bindManyToManySecondPass(Map<String, PersistentClass> persistentCla
 					targetEntity,
 					hqlOrderBy
 			);
-			bindManyToManyInverseForeignKey( targetEntity, inverseJoinColumns, element, oneToMany, buildingContext );
+			bindManyToManyInverseForeignKey( targetEntity, inverseJoinColumns, element, oneToMany );
 		}
 		else if ( isManyToAny ) {
 			handleManyToAny(
@@ -2052,7 +2051,6 @@ else if ( isManyToAny ) {
 					elementType,
 					property,
 					propertyHolder,
-					buildingContext,
 					hqlOrderBy
 			);
 		}
@@ -2062,12 +2060,11 @@ else if ( isManyToAny ) {
 
 	private void handleElementCollection(
 			Collection collection,
-			AnnotatedColumn[] elementColumns,
+			AnnotatedColumns elementColumns,
 			boolean isEmbedded,
 			XClass elementType,
 			XProperty property,
 			PropertyHolder parentPropertyHolder,
-			MetadataBuildingContext buildingContext,
 			String hqlOrderBy) {
 		final XClass elementClass;
 		final AnnotatedClassType classType;
@@ -2172,24 +2169,14 @@ else if ( owner.getIdentifierMapper() != null && owner.getIdentifierMapper().get
 			final BasicValueBinder elementBinder =
 					new BasicValueBinder( BasicValueBinder.Kind.COLLECTION_ELEMENT, buildingContext );
 			elementBinder.setReturnedClassName( elementType.getName() );
-			if ( elementColumns == null || elementColumns.length == 0 ) {
+			final AnnotatedColumns actualColumns = createElementColumnsIfNecessary(
-				elementColumns = new AnnotatedColumn[1];
+					collection,
-				AnnotatedColumn column = new AnnotatedColumn();
+					elementColumns,
-				column.setImplicit( false );
+					Collection.DEFAULT_ELEMENT_COLUMN_NAME,
-				//not following the spec but more clean
+					null,
-				column.setNullable( true );
+					buildingContext
-				column.setLogicalColumnName( Collection.DEFAULT_ELEMENT_COLUMN_NAME );
+			);
-				//TODO create an EMPTY_JOINS collection
+			elementBinder.setColumns( actualColumns );
-				column.setJoins( new HashMap<>() );
-				column.setBuildingContext(buildingContext);
-				column.bind();
-				elementColumns[0] = column;
-			}
-			//override the table
-			for (AnnotatedColumn column : elementColumns) {
-				column.setTable( collection.getCollectionTable() );
-			}
-			elementBinder.setColumns(elementColumns);
 			elementBinder.setType(
 					property,
 					elementClass,
@@ -2206,6 +2193,34 @@ else if ( owner.getIdentifierMapper() != null && owner.getIdentifierMapper().get
 		}
 	}
 
+	static AnnotatedColumns createElementColumnsIfNecessary(
+			Collection collection,
+			AnnotatedColumns elementColumns,
+			String defaultName,
+			Long defaultLength,
+			MetadataBuildingContext context) {
+		if ( elementColumns == null || isEmpty( elementColumns.getColumns() ) ) {
+			final AnnotatedColumn column = new AnnotatedColumn();
+			column.setLogicalColumnName( defaultName );
+			if ( defaultLength!=null ) {
+				column.setLength( defaultLength );
+			}
+			column.setImplicit( false );
+			//not following the spec but more clean
+			column.setNullable( true );
+			//TODO create an EMPTY_JOINS collection
+			column.setJoins( new HashMap<>() );
+			column.setBuildingContext( context );
+			column.bind();
+			final AnnotatedColumns result = new AnnotatedColumns();
+			result.setColumns( new AnnotatedColumn[] { column } );
+			elementColumns = result;
+		}
+		//override the table
+		elementColumns.setTable( collection.getCollectionTable() );
+		return elementColumns;
+	}
+
 	private ManyToOne handleCollectionOfEntities(
 			Collection collection,
 			XClass elementType,
@@ -2214,7 +2229,7 @@ private ManyToOne handleCollectionOfEntities(
 			MetadataBuildingContext buildingContext,
 			PersistentClass collectionEntity,
 			String hqlOrderBy) {
-		ManyToOne element = new ManyToOne( buildingContext,  collection.getCollectionTable() );
+		final ManyToOne element = new ManyToOne( buildingContext,  collection.getCollectionTable() );
 		collection.setElement( element );
 		element.setReferencedEntityName( elementType.getName() );
 		//element.setFetchMode( fetchMode );
@@ -2273,16 +2288,14 @@ private void handleManyToAny(
 				buildingContext.getBootstrapContext().getReflectionManager()
 		);
 
-		XProperty prop = inferredData.getProperty();
+		final XProperty prop = inferredData.getProperty();
 		final jakarta.persistence.Column discriminatorColumnAnn = prop.getAnnotation( jakarta.persistence.Column.class );
 		final Formula discriminatorFormulaAnn = getOverridableAnnotation( prop, Formula.class, buildingContext);
 
 		//override the table
-		for ( AnnotatedColumn column : inverseJoinColumns.getColumns() ) {
+		inverseJoinColumns.setTable( collection.getCollectionTable() );
-			column.setTable( collection.getCollectionTable() );
-		}
 
-		ManyToAny anyAnn = property.getAnnotation( ManyToAny.class );
+		final ManyToAny anyAnn = property.getAnnotation( ManyToAny.class );
 		final Any any = buildAnyValue(
 				discriminatorColumnAnn,
 				discriminatorFormulaAnn,
@@ -2486,8 +2499,7 @@ private static void checkFilterConditions(Collection collection) {
 	private void bindCollectionSecondPass(
 			PersistentClass targetEntity,
 			AnnotatedJoinColumns joinColumns,
-			boolean cascadeDeleteEnabled,
+			boolean cascadeDeleteEnabled) {
-			MetadataBuildingContext context) {
 
 		if ( !hasMappedBy() ) {
 			createSyntheticPropertyReference(
@@ -2497,7 +2509,7 @@ private void bindCollectionSecondPass(
 					collection,
 					propertyName,
 					false,
-					context
+					buildingContext
 			);
 		}
 
@@ -2505,10 +2517,9 @@ private void bindCollectionSecondPass(
 				collection,
 				joinColumns,
 				cascadeDeleteEnabled,
-				context.getBuildingOptions().isNoConstraintByDefault(),
+				buildingContext.getBuildingOptions().isNoConstraintByDefault(),
 				property,
-				propertyHolder,
+				propertyHolder
-				context
 		);
 
 		if ( property.isAnnotationPresent( ElementCollection.class ) ) {
@@ -2521,7 +2532,7 @@ private void bindCollectionSecondPass(
 				joinColumns,
 				key,
 				false,
-				context
+				buildingContext
 		);
 		key.sortProperties();
 	}
@@ -2545,8 +2556,7 @@ public void bindManyToManyInverseForeignKey(
 			PersistentClass targetEntity,
 			AnnotatedJoinColumns joinColumns,
 			SimpleValue value,
-			boolean unique,
+			boolean unique) {
-			MetadataBuildingContext context) {
 		if ( hasMappedBy() ) {
 			final Property property = targetEntity.getRecursiveProperty( mappedBy );
 			final List<Selectable> mappedByColumns = mappedByColumns( targetEntity, property );
@@ -2554,12 +2564,12 @@ public void bindManyToManyInverseForeignKey(
 			for ( Selectable selectable: mappedByColumns ) {
 				firstColumn.linkValueUsingAColumnCopy( (Column) selectable, value );
 			}
-			final String referencedPropertyName = context.getMetadataCollector()
+			final String referencedPropertyName = buildingContext.getMetadataCollector()
 					.getPropertyReferencedAssociation( targetEntity.getEntityName(), mappedBy );
 			if ( referencedPropertyName != null ) {
 				//TODO always a many to one?
 				( (ManyToOne) value ).setReferencedPropertyName( referencedPropertyName );
-				context.getMetadataCollector()
+				buildingContext.getMetadataCollector()
 						.addUniquePropertyReference( targetEntity.getEntityName(), referencedPropertyName );
 			}
 			( (ManyToOne) value ).setReferenceToPrimaryKey( referencedPropertyName == null );
@@ -2573,7 +2583,7 @@ public void bindManyToManyInverseForeignKey(
 					value,
 					propertyName,
 					true,
-					context
+					buildingContext
 			);
 			if ( notFoundAction == NotFoundAction.IGNORE ) {
 				value.disableForeignKey();
@@ -2584,7 +2594,7 @@ public void bindManyToManyInverseForeignKey(
 					joinColumns,
 					value,
 					unique,
-					context
+					buildingContext
 			);
 		}
 	}
@@ -2617,7 +2627,7 @@ public void setExplicitAssociationTable(boolean explicitAssocTable) {
 		this.isExplicitAssociationTable = explicitAssocTable;
 	}
 
-	public void setElementColumns(AnnotatedColumn[] elementColumns) {
+	public void setElementColumns(AnnotatedColumns elementColumns) {
 		this.elementColumns = elementColumns;
 	}
 
@@ -2637,7 +2647,7 @@ public void setNotFoundAction(NotFoundAction notFoundAction) {
 		this.notFoundAction = notFoundAction;
 	}
 
-	public void setMapKeyColumns(AnnotatedColumn[] mapKeyColumns) {
+	public void setMapKeyColumns(AnnotatedColumns mapKeyColumns) {
 		this.mapKeyColumns = mapKeyColumns;
 	}
 

hibernate-core/src/main/java/org/hibernate/cfg/annotations/EntityBinder.java

@@ -789,7 +789,7 @@ private static void bindDiscriminatorColumnToRootPersistentClass(
 			}
 			discriminatorColumn.setJoins( secondaryTables );
 			discriminatorColumn.setPropertyHolder( propertyHolder );
-			BasicValue discriminatorColumnBinding = new BasicValue( context, rootClass.getTable() );
+			final BasicValue discriminatorColumnBinding = new BasicValue( context, rootClass.getTable() );
 			rootClass.setDiscriminator( discriminatorColumnBinding );
 			discriminatorColumn.linkWithValue( discriminatorColumnBinding );
 			discriminatorColumnBinding.setTypeName( discriminatorColumn.getDiscriminatorTypeName() );

hibernate-core/src/main/java/org/hibernate/cfg/annotations/IdBagBinder.java

@@ -12,12 +12,9 @@
 
 import org.hibernate.MappingException;
 import org.hibernate.annotations.CollectionId;
-import org.hibernate.annotations.NotFoundAction;
-import org.hibernate.annotations.common.reflection.XClass;
-import org.hibernate.annotations.common.reflection.XProperty;
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.cfg.AnnotatedColumn;
-import org.hibernate.cfg.AnnotatedJoinColumn;
+import org.hibernate.cfg.AnnotatedColumns;
 import org.hibernate.cfg.IdGeneratorResolverSecondPass;
 import org.hibernate.cfg.PropertyData;
 import org.hibernate.cfg.PropertyInferredData;
@@ -71,7 +68,7 @@ protected boolean bindStarToManySecondPass(Map<String, PersistentClass> persiste
 				"id"
 		);
 
-		final AnnotatedColumn[] idColumns = AnnotatedColumn.buildColumnsFromAnnotations(
+		final AnnotatedColumns idColumns = AnnotatedColumn.buildColumnsFromAnnotations(
 				new Column[] { collectionIdAnn.column() },
 				null,
 				Nullability.FORCED_NOT_NULL,
@@ -82,7 +79,7 @@ protected boolean bindStarToManySecondPass(Map<String, PersistentClass> persiste
 		);
 
 		//we need to make sure all id columns must be not-null.
-		for ( AnnotatedColumn idColumn:idColumns ) {
+		for ( AnnotatedColumn idColumn : idColumns.getColumns() ) {
 			idColumn.setNullable( false );
 		}
 

hibernate-core/src/main/java/org/hibernate/cfg/annotations/ListBinder.java

@@ -12,8 +12,9 @@
 import org.hibernate.MappingException;
 import org.hibernate.annotations.OrderBy;
 import org.hibernate.boot.spi.MetadataBuildingContext;
-import org.hibernate.cfg.CollectionSecondPass;
 import org.hibernate.cfg.AnnotatedColumn;
+import org.hibernate.cfg.AnnotatedColumns;
+import org.hibernate.cfg.CollectionSecondPass;
 import org.hibernate.cfg.PropertyHolder;
 import org.hibernate.cfg.PropertyHolderBuilder;
 import org.hibernate.cfg.SecondPass;
@@ -87,7 +88,9 @@ private void bindIndex() {
 		}
 		indexColumn.setPropertyHolder( valueHolder );
 		final BasicValueBinder valueBinder = new BasicValueBinder( BasicValueBinder.Kind.LIST_INDEX, buildingContext );
-		valueBinder.setColumns( new AnnotatedColumn[] { indexColumn } );
+		final AnnotatedColumns result = new AnnotatedColumns();
+		result.setColumns( new AnnotatedColumn[] { indexColumn } );
+		valueBinder.setColumns(result);
 		valueBinder.setReturnedClassName( Integer.class.getName() );
 		valueBinder.setType( property, getElementType(), null, null );
 //			valueBinder.setExplicitType( "integer" );
@@ -95,7 +98,13 @@ private void bindIndex() {
 		indexColumn.linkWithValue( indexValue );
 		listValueMapping.setIndex( indexValue );
 		listValueMapping.setBaseIndex( indexColumn.getBase() );
-		if ( listValueMapping.isOneToMany() && !listValueMapping.getKey().isNullable() && !listValueMapping.isInverse() ) {
+		createBackref( listValueMapping );
+	}
+
+	private void createBackref(List listValueMapping) {
+		if ( listValueMapping.isOneToMany()
+				&& !listValueMapping.getKey().isNullable()
+				&& !listValueMapping.isInverse() ) {
 			final String entityName = ( (OneToMany) listValueMapping.getElement() ).getReferencedEntityName();
 			final PersistentClass referenced = buildingContext.getMetadataCollector().getEntityBinding( entityName );
 			final IndexBackref backref = new IndexBackref();

hibernate-core/src/main/java/org/hibernate/cfg/annotations/MapBinder.java

@@ -6,7 +6,6 @@
  */
 package org.hibernate.cfg.annotations;
 
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
@@ -22,11 +21,11 @@
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.cfg.AccessType;
 import org.hibernate.cfg.AnnotatedClassType;
+import org.hibernate.cfg.AnnotatedColumns;
 import org.hibernate.cfg.AnnotatedJoinColumns;
 import org.hibernate.cfg.AnnotationBinder;
 import org.hibernate.cfg.CollectionPropertyHolder;
 import org.hibernate.cfg.CollectionSecondPass;
-import org.hibernate.cfg.AnnotatedColumn;
 import org.hibernate.cfg.AnnotatedJoinColumn;
 import org.hibernate.cfg.InheritanceState;
 import org.hibernate.cfg.PropertyData;
@@ -100,7 +99,6 @@ public void secondPass(Map<String, PersistentClass> persistentClasses)
 						mapKeyPropertyName,
 						property,
 						isEmbedded,
-						buildingContext,
 						mapKeyColumns,
 						mapKeyManyToManyColumns,
 						inverseJoinColumns != null ? inverseJoinColumns.getPropertyName() : null
@@ -123,7 +121,7 @@ private void makeOneToManyMapKeyColumnNullableIfNotInProperty(
 			if ( selectable.isFormula() ) {
 				throw new AssertionFailure( "Map key mapped by @MapKeyColumn is a Formula" );
 			}
-			Column column = (Column) selectable;
+			final Column column = (Column) selectable;
 			if ( !column.isNullable() ) {
 				final PersistentClass persistentClass = ( ( OneToMany ) map.getElement() ).getAssociatedClass();
 				// check if the index column has been mapped by the associated entity to a property;
@@ -158,59 +156,153 @@ private void bindKeyFromAssociationTable(
 			String mapKeyPropertyName,
 			XProperty property,
 			boolean isEmbedded,
-			MetadataBuildingContext buildingContext,
+			AnnotatedColumns mapKeyColumns,
-			AnnotatedColumn[] mapKeyColumns,
 			AnnotatedJoinColumns mapKeyManyToManyColumns,
 			String targetPropertyName) {
 		if ( mapKeyPropertyName != null ) {
 			//this is an EJB3 @MapKey
-			PersistentClass associatedClass = persistentClasses.get( elementType.getName() );
+			handleExplicitMapKey( elementType, persistentClasses, mapKeyPropertyName );
+		}
+		else {
+			//this is a true Map mapping
+			final String mapKeyType = getKeyType( property );
+			final PersistentClass collectionEntity = persistentClasses.get( mapKeyType );
+			final boolean isIndexOfEntities = collectionEntity != null;
+			final ManyToOne element;
+			org.hibernate.mapping.Map map = (org.hibernate.mapping.Map) this.collection;
+			if ( isIndexOfEntities ) {
+				element = handleCollectionKeyedByEntities( buildingContext, mapKeyType, map );
+			}
+			else {
+				element = null;
+				final XClass keyClass;
+				final AnnotatedClassType classType;
+				if ( PRIMITIVE_NAMES.contains( mapKeyType ) ) {
+					classType = AnnotatedClassType.NONE;
+					keyClass = null;
+				}
+				else {
+					final BootstrapContext bootstrapContext = buildingContext.getBootstrapContext();
+					final Class<Object> mapKeyClass = bootstrapContext.getClassLoaderAccess().classForName( mapKeyType );
+					keyClass = bootstrapContext.getReflectionManager().toXClass( mapKeyClass );
+					// force in case of attribute override naming the key
+					classType = isEmbedded || mappingDefinedAttributeOverrideOnMapKey( property )
+							? AnnotatedClassType.EMBEDDABLE
+							: buildingContext.getMetadataCollector().getClassType( keyClass );
+				}
+
+				handleIndex(
+						property,
+						mapKeyColumns,
+						mapKeyType,
+						map,
+						keyClass,
+						classType,
+						buildCollectionPropertyHolder( property, map, keyClass ),
+						getAccessType( map )
+				);
+			}
+			//FIXME pass the Index Entity JoinColumns
+			if ( !collection.isOneToMany() ) {
+				//index column should not be null
+				for ( AnnotatedJoinColumn column : mapKeyManyToManyColumns.getColumns() ) {
+					column.forceNotNull();
+				}
+			}
+
+			if ( element != null ) {
+				handleForeignKey( property, element );
+			}
+
+			if ( isIndexOfEntities ) {
+				bindManyToManyInverseForeignKey(
+						collectionEntity,
+						mapKeyManyToManyColumns,
+						element,
+						false //a map key column has no unique constraint
+				);
+			}
+		}
+	}
+
+	private static String getKeyType(XProperty property) {
+		//target has priority over reflection for the map key type
+		//JPA 2 has priority
+		final Class<?> target = property.isAnnotationPresent( MapKeyClass.class )
+				? property.getAnnotation( MapKeyClass.class ).value()
+				: void.class;
+		return void.class.equals( target ) ? property.getMapKey().getName() : target.getName();
+	}
+
+	private void handleExplicitMapKey(
+			XClass elementType,
+			Map<String, PersistentClass> persistentClasses,
+			String mapKeyPropertyName) {
+		final PersistentClass associatedClass = persistentClasses.get( elementType.getName() );
 		if ( associatedClass == null ) {
 			throw new AnnotationException( "Association '" + safeCollectionRole()
 					+ "' targets the type '" + elementType.getName() + "' which is not an '@Entity' type" );
 		}
-			Property mapProperty = findPropertyByName( associatedClass, mapKeyPropertyName );
+		final Property mapProperty = findPropertyByName( associatedClass, mapKeyPropertyName);
 		if ( mapProperty == null ) {
 			throw new AnnotationException( "Map key property '" + mapKeyPropertyName
 					+ "' not found in target entity '" + associatedClass.getEntityName() + "'" );
 		}
-			org.hibernate.mapping.Map map = (org.hibernate.mapping.Map) this.collection;
+		final org.hibernate.mapping.Map map = (org.hibernate.mapping.Map) this.collection;
 		// HHH-11005 - if InheritanceType.JOINED then need to find class defining the column
-			InheritanceState inheritanceState = inheritanceStatePerClass.get( elementType );
+		final InheritanceState inheritanceState = inheritanceStatePerClass.get(elementType);
-			PersistentClass targetPropertyPersistentClass = InheritanceType.JOINED.equals( inheritanceState.getType() ) ?
+		final PersistentClass targetEntity = InheritanceType.JOINED == inheritanceState.getType()
-					mapProperty.getPersistentClass() :
+				? mapProperty.getPersistentClass()
-					associatedClass;
+				: associatedClass;
-			Value indexValue = createFormulatedValue(
+		final Value indexValue = createFormulatedValue( mapProperty.getValue(), map, associatedClass, targetEntity );
-					mapProperty.getValue(), map, targetPropertyName, associatedClass, targetPropertyPersistentClass, buildingContext
-			);
 		map.setIndex( indexValue );
 		map.setMapKeyPropertyName(mapKeyPropertyName);
 	}
-		else {
+
-			//this is a true Map mapping
+	private CollectionPropertyHolder buildCollectionPropertyHolder(
-			//TODO ugly copy/paste from CollectionBinder.bindManyToManySecondPass
+			XProperty property,
-			String mapKeyType;
+			org.hibernate.mapping.Map map,
-			Class<?> target = void.class;
+			XClass keyClass) {
-			/*
+		final CollectionPropertyHolder holder = buildPropertyHolder(
-			 * target has priority over reflection for the map key type
+				map,
-			 * JPA 2 has priority
+				qualify( map.getRole(), "mapkey" ),
-			 */
+				keyClass,
-			if ( property.isAnnotationPresent( MapKeyClass.class ) ) {
+				property,
-				target = property.getAnnotation( MapKeyClass.class ).value();
+				propertyHolder,
+				buildingContext
+		);
+		// 'propertyHolder' is the PropertyHolder for the owner of the collection
+		// 'holder' is the CollectionPropertyHolder.
+		// 'property' is the collection XProperty
+		propertyHolder.startingProperty(property);
+		holder.prepare(property);
+		return holder;
 	}
-			if ( !void.class.equals( target ) ) {
+
-				mapKeyType = target.getName();
+	private void handleForeignKey(XProperty property, ManyToOne element) {
+		final jakarta.persistence.ForeignKey foreignKey = getMapKeyForeignKey( property );
+		if ( foreignKey != null ) {
+			final ConstraintMode constraintMode = foreignKey.value();
+			if ( constraintMode == ConstraintMode.NO_CONSTRAINT
+					|| constraintMode == ConstraintMode.PROVIDER_DEFAULT
+							&& getBuildingContext().getBuildingOptions().isNoConstraintByDefault() ) {
+				element.disableForeignKey();
 			}
 			else {
-				mapKeyType = property.getMapKey().getName();
+				element.setForeignKeyName( nullIfEmpty( foreignKey.name() ) );
+				element.setForeignKeyDefinition( nullIfEmpty( foreignKey.foreignKeyDefinition() ) );
 			}
-			PersistentClass collectionEntity = persistentClasses.get( mapKeyType );
+		}
-			boolean isIndexOfEntities = collectionEntity != null;
+	}
-			ManyToOne element = null;
+
-			org.hibernate.mapping.Map mapValue = (org.hibernate.mapping.Map) this.collection;
+	//similar to CollectionBinder.handleCollectionOfEntities()
-			if ( isIndexOfEntities ) {
+	private static ManyToOne handleCollectionKeyedByEntities(
-				element = new ManyToOne( buildingContext, mapValue.getCollectionTable() );
+			MetadataBuildingContext context,
-				mapValue.setIndex( element );
+			String mapKeyType,
+			org.hibernate.mapping.Map map) {
+		final ManyToOne element;
+		element = new ManyToOne(context, map.getCollectionTable() );
+		map.setIndex( element );
 		element.setReferencedEntityName(mapKeyType);
 		//element.setFetchMode( fetchMode );
 		//element.setLazy( fetchMode != FetchMode.JOIN );
@@ -218,44 +310,12 @@ private void bindKeyFromAssociationTable(
 		element.setFetchMode( FetchMode.JOIN );
 		element.setLazy( false );
 		//does not make sense for a map key element.setIgnoreNotFound( ignoreNotFound );
-			}
+		return element;
-			else {
-				final XClass keyXClass;
-				AnnotatedClassType classType;
-				if ( PRIMITIVE_NAMES.contains( mapKeyType ) ) {
-					classType = AnnotatedClassType.NONE;
-					keyXClass = null;
-				}
-				else {
-					final BootstrapContext bootstrapContext = buildingContext.getBootstrapContext();
-					final Class<Object> mapKeyClass = bootstrapContext.getClassLoaderAccess().classForName( mapKeyType );
-					keyXClass = bootstrapContext.getReflectionManager().toXClass( mapKeyClass );
-
-					classType = buildingContext.getMetadataCollector().getClassType( keyXClass );
-					// force in case of attribute override naming the key
-					if ( isEmbedded || mappingDefinedAttributeOverrideOnMapKey( property ) ) {
-						classType = AnnotatedClassType.EMBEDDABLE;
-					}
 	}
 
-				CollectionPropertyHolder holder = buildPropertyHolder(
+	private static AccessType getAccessType(org.hibernate.mapping.Map map) {
-						mapValue,
+		final PersistentClass owner = map.getOwner();
-						qualify( mapValue.getRole(), "mapkey" ),
+		final AccessType accessType;
-						keyXClass,
-						property,
-						propertyHolder,
-						buildingContext
-				);
-
-
-				// 'propertyHolder' is the PropertyHolder for the owner of the collection
-				// 'holder' is the CollectionPropertyHolder.
-				// 'property' is the collection XProperty
-				propertyHolder.startingProperty( property );
-				holder.prepare( property );
-
-				PersistentClass owner = mapValue.getOwner();
-				AccessType accessType;
 		// FIXME support @Access for collection of elements
 		// String accessType = access != null ? access.value() : null;
 		if ( owner.getIdentifierProperty() != null ) {
@@ -272,21 +332,32 @@ else if ( owner.getIdentifierMapper() != null && owner.getIdentifierMapper().get
 		else {
 			throw new AssertionFailure( "Unable to guess collection property accessor name" );
 		}
+		return accessType;
+	}
+
+	private void handleIndex(
+			XProperty property,
+			AnnotatedColumns mapKeyColumns,
+			String mapKeyType,
+			org.hibernate.mapping.Map map,
+			XClass keyClass,
+			AnnotatedClassType classType,
+			CollectionPropertyHolder holder,
+			AccessType accessType) {
 		final Class<? extends CompositeUserType<?>> compositeUserType = resolveCompositeUserType(
 				property,
-						keyXClass,
+				keyClass,
 				buildingContext
 		);
-				if ( AnnotatedClassType.EMBEDDABLE.equals( classType ) || compositeUserType != null ) {
-					EntityBinder entityBinder = new EntityBinder();
 
-					PropertyData inferredData = isHibernateExtensionMapping()
+		if ( AnnotatedClassType.EMBEDDABLE == classType || compositeUserType != null ) {
-							? new PropertyPreloadedData(AccessType.PROPERTY, "index", keyXClass)
+			final EntityBinder entityBinder = new EntityBinder();
-							: new PropertyPreloadedData(AccessType.PROPERTY, "key", keyXClass);
+			final PropertyData inferredData = isHibernateExtensionMapping()
+					? new PropertyPreloadedData( AccessType.PROPERTY, "index", keyClass)
 					// "key" is the JPA 2 prefix for map keys
-
+					: new PropertyPreloadedData( AccessType.PROPERTY, "key", keyClass);
 			//TODO be smart with isNullable
-					Component component = AnnotationBinder.fillComponent(
+			final Component component = AnnotationBinder.fillComponent(
 					holder,
 					inferredData,
 					accessType,
@@ -300,76 +371,30 @@ else if ( owner.getIdentifierMapper() != null && owner.getIdentifierMapper().get
 					buildingContext,
 					inheritanceStatePerClass
 			);
-					mapValue.setIndex( component );
+			map.setIndex( component );
 		}
 		else {
 			final BasicValueBinder elementBinder = new BasicValueBinder( BasicValueBinder.Kind.MAP_KEY, buildingContext );
 			elementBinder.setReturnedClassName(mapKeyType);
-
+			final AnnotatedColumns keyColumns = createElementColumnsIfNecessary(
-					AnnotatedColumn[] elementColumns = mapKeyColumns;
+					collection,
-					if ( elementColumns == null || elementColumns.length == 0 ) {
+					mapKeyColumns,
-						elementColumns = new AnnotatedColumn[1];
+					Collection.DEFAULT_KEY_COLUMN_NAME,
-						AnnotatedColumn column = new AnnotatedColumn();
+					Size.DEFAULT_LENGTH, //TODO: is this really necessary??!!
-						column.setImplicit( false );
+					buildingContext
-						column.setNullable( true );
+			);
-						column.setLength( Size.DEFAULT_LENGTH );
+			elementBinder.setColumns( keyColumns );
-						column.setLogicalColumnName( Collection.DEFAULT_KEY_COLUMN_NAME );
-						//TODO create an EMPTY_JOINS collection
-						column.setJoins( new HashMap<>() );
-						column.setBuildingContext( buildingContext );
-						column.bind();
-						elementColumns[0] = column;
-					}
-					//override the table
-					for (AnnotatedColumn column : elementColumns) {
-						column.setTable( mapValue.getCollectionTable() );
-					}
-					elementBinder.setColumns( elementColumns );
 			//do not call setType as it extracts the type from @Type
 			//the algorithm generally does not apply for map key anyway
 			elementBinder.setType(
 					property,
-							keyXClass,
+					keyClass,
-							this.collection.getOwnerEntityName(),
+					collection.getOwnerEntityName(),
-							holder.mapKeyAttributeConverterDescriptor( property, keyXClass )
+					holder.mapKeyAttributeConverterDescriptor(property, keyClass)
 			);
 			elementBinder.setPersistentClassName( propertyHolder.getEntityName() );
 			elementBinder.setAccessType(accessType);
-					mapValue.setIndex( elementBinder.make() );
+			map.setIndex( elementBinder.make() );
-				}
-			}
-			//FIXME pass the Index Entity JoinColumns
-			if ( !collection.isOneToMany() ) {
-				//index column should not be null
-				for ( AnnotatedJoinColumn col : mapKeyManyToManyColumns.getColumns() ) {
-					col.forceNotNull();
-				}
-			}
-
-			if ( element != null ) {
-				final jakarta.persistence.ForeignKey foreignKey = getMapKeyForeignKey( property );
-				if ( foreignKey != null ) {
-					if ( foreignKey.value() == ConstraintMode.NO_CONSTRAINT
-							|| foreignKey.value() == ConstraintMode.PROVIDER_DEFAULT
-									&& getBuildingContext().getBuildingOptions().isNoConstraintByDefault() ) {
-						element.disableForeignKey();
-					}
-					else {
-						element.setForeignKeyName( nullIfEmpty( foreignKey.name() ) );
-						element.setForeignKeyDefinition( nullIfEmpty( foreignKey.foreignKeyDefinition() ) );
-					}
-				}
-			}
-
-			if ( isIndexOfEntities ) {
-				bindManyToManyInverseForeignKey(
-						collectionEntity,
-						mapKeyManyToManyColumns,
-						element,
-						false, //a map key column has no unique constraint
-						buildingContext
-				);
-			}
 		}
 	}
 
@@ -429,13 +454,11 @@ private boolean namedMapKey(AttributeOverride annotation) {
 		return annotation.name().startsWith( "key." );
 	}
 
-	protected Value createFormulatedValue(
+	private Value createFormulatedValue(
 			Value value,
 			Collection collection,
-			String targetPropertyName,
 			PersistentClass associatedClass,
-			PersistentClass targetPropertyPersistentClass,
+			PersistentClass targetPropertyPersistentClass) {
-			MetadataBuildingContext buildingContext) {
 		final Table mapKeyTable;
 		// HHH-11005 - only if we are OneToMany and location of map key property is at a different level, need to add a select
 		if ( !associatedClass.equals( targetPropertyPersistentClass ) ) {
@@ -464,14 +487,7 @@ protected Value createFormulatedValue(
 				newProperty.setPropertyAccessorName( current.getPropertyAccessorName() );
 				newProperty.setSelectable( current.isSelectable() );
 				newProperty.setValue(
-						createFormulatedValue(
+						createFormulatedValue( current.getValue(), collection, associatedClass, associatedClass )
-								current.getValue(),
-								collection,
-								targetPropertyName,
-								associatedClass,
-								associatedClass,
-								buildingContext
-						)
 				);
 				indexComponent.addProperty( newProperty );
 			}
@@ -504,8 +520,8 @@ else if ( value instanceof SimpleValue ) {
 			SimpleValue sourceValue = (SimpleValue) value;
 			SimpleValue targetValue;
 			if ( value instanceof ManyToOne ) {
-				ManyToOne sourceManyToOne = (ManyToOne) sourceValue;
+				final ManyToOne sourceManyToOne = (ManyToOne) sourceValue;
-				ManyToOne targetManyToOne = new ManyToOne( getBuildingContext(), mapKeyTable );
+				final ManyToOne targetManyToOne = new ManyToOne( getBuildingContext(), mapKeyTable );
 				targetManyToOne.setFetchMode( FetchMode.DEFAULT );
 				targetManyToOne.setLazy( true );
 				//targetValue.setIgnoreNotFound( ); does not make sense for a map key

hibernate-core/src/main/java/org/hibernate/cfg/annotations/PropertyBinder.java

@@ -23,6 +23,7 @@
 import org.hibernate.annotations.common.reflection.XProperty;
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.cfg.AccessType;
+import org.hibernate.cfg.AnnotatedColumns;
 import org.hibernate.cfg.AnnotationBinder;
 import org.hibernate.cfg.AnnotatedColumn;
 import org.hibernate.cfg.InheritanceState;
@@ -66,7 +67,7 @@ public class PropertyBinder {
 	private boolean lazy;
 	private String lazyGroup;
 	private AccessType accessType;
-	private AnnotatedColumn[] columns;
+	private AnnotatedColumns columns;
 	private PropertyHolder holder;
 	private Value value;
 	private boolean insertable = true;
@@ -128,9 +129,10 @@ public void setAccessType(AccessType accessType) {
 		this.accessType = accessType;
 	}
 
-	public void setColumns(AnnotatedColumn[] columns) {
+	public void setColumns(AnnotatedColumns columns) {
-		insertable = columns[0].isInsertable();
+		final AnnotatedColumn firstColumn = columns.getColumns()[0];
-		updatable = columns[0].isUpdatable();
+		insertable = firstColumn.isInsertable();
+		updatable = firstColumn.isUpdatable();
 		//consistency is checked later when we know the property name
 		this.columns = columns;
 	}
@@ -355,7 +357,7 @@ private void inferOptimisticLocking(Property prop) {
 			prop.setOptimisticLocked( ((Collection) value).isOptimisticLocked() );
 		}
 		else if ( property != null && property.isAnnotationPresent(OptimisticLock.class) ) {
-			OptimisticLock lockAnn = property.getAnnotation(OptimisticLock.class);
+			final OptimisticLock lockAnn = property.getAnnotation(OptimisticLock.class);
 			validateOptimisticLock(lockAnn);
 			prop.setOptimisticLocked( !lockAnn.excluded() );
 		}

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

@@ -274,7 +274,6 @@ private void checkSelectable(Selectable incomingColumn) {
 	@Override
 	public void addColumn(Column incomingColumn, boolean isInsertable, boolean isUpdatable) {
 		super.addColumn( incomingColumn, isInsertable, isUpdatable );
-
 		checkSelectable( incomingColumn );
 	}