HHH-14584 Allow PhysicalNamingStrategy implementations to detect when a name is implicit or explicit

Author: peter1123581321

hibernate-core/src/main/java/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java

@@ -917,15 +917,20 @@ public Table addTable(
 			String name,
 			String subselectFragment,
 			boolean isAbstract,
-			MetadataBuildingContext buildingContext) {
+			MetadataBuildingContext buildingContext,
+			boolean isExplicit) {
 		final Namespace namespace = getDatabase().locateNamespace(
 				getDatabase().toIdentifier( catalogName ),
 				getDatabase().toIdentifier( schemaName )
 		);
 
 		// annotation binding depends on the "table name" for @Subselect bindings
 		// being set into the generated table (mainly to avoid later NPE), but for now we need to keep that :(
-		final Identifier logicalName = name != null ? getDatabase().toIdentifier( name ) : null;
+		Identifier logicalName = null;
+		if ( name != null ) {
+			logicalName = getDatabase().toIdentifier( name );
+			logicalName.setExplicit( isExplicit );
+		}
 
 		if ( subselectFragment != null ) {
 			return new Table( buildingContext.getCurrentContributorName(),

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

@@ -358,9 +358,10 @@ public boolean isNameDeferred() {
 	 * @return {@code true} if a name could be inferred
 	 */
 	boolean inferColumnNameIfPossible(String columnName, String propertyName, boolean applyNamingStrategy) {
-		if ( !isEmpty( columnName ) || !isEmpty( propertyName ) ) {
+		if ( isNotEmpty( columnName ) || isNotEmpty( propertyName ) ) {
 			final String logicalColumnName = resolveLogicalColumnName( columnName, propertyName );
-			mappingColumn.setName( processColumnName( logicalColumnName, applyNamingStrategy ) );
+			mappingColumn.setName(
+					processColumnName( logicalColumnName, applyNamingStrategy, isNotEmpty( columnName ) ) );
 			return true;
 		}
 		else {
@@ -411,11 +412,13 @@ private String applyEmbeddedColumnNaming(String inferredColumnName, ComponentPro
 		return result;
 	}
 
-	protected String processColumnName(String columnName, boolean applyNamingStrategy) {
+	protected String processColumnName(String columnName, boolean applyNamingStrategy, boolean isExplicit) {
 		if ( applyNamingStrategy ) {
 			final Database database = getDatabase();
+			Identifier identifier = database.toIdentifier( columnName );
+			identifier.setExplicit( isExplicit );
 			return getPhysicalNamingStrategy()
-					.toPhysicalColumnName( database.toIdentifier( columnName ), database.getJdbcEnvironment() )
+					.toPhysicalColumnName( identifier, database.getJdbcEnvironment() )
 					.render( database.getDialect() );
 		}
 		else {

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

@@ -454,7 +454,8 @@ public void overrideFromReferencedColumnIfNecessary(Column column) {
 	@Override
 	boolean inferColumnNameIfPossible(String columnName, String propertyName, boolean applyNamingStrategy) {
 		if ( isNotEmpty( columnName ) ) {
-			getMappingColumn().setName( processColumnName( columnName, applyNamingStrategy ) );
+			getMappingColumn().setName(
+					processColumnName( columnName, applyNamingStrategy, isNotEmpty( columnName ) ) );
 			return true;
 		}
 		else {

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

@@ -1773,7 +1773,10 @@ public MetadataBuildingContext getBuildingContext() {
 
 		@Override
 		public Identifier handleExplicitName(String explicitName, MetadataBuildingContext buildingContext) {
-			return jdbcEnvironment( buildingContext ).getIdentifierHelper().toIdentifier( explicitName );
+			Identifier identifier = jdbcEnvironment( buildingContext ).getIdentifierHelper()
+					.toIdentifier( explicitName );
+			identifier.setExplicit( true );
+			return identifier;
 		}
 
 		@Override

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

@@ -541,7 +541,8 @@ private static Table addTable(
 					logicalName.render(),
 					subselect,
 					isAbstract,
-					buildingContext
+					buildingContext,
+					logicalName.isExplicit()
 			);
 		}
 	}

hibernate-core/src/main/java/org/hibernate/boot/model/naming/Identifier.java

@@ -23,6 +23,7 @@
 public class Identifier implements Comparable<Identifier> {
 	private final String text;
 	private final boolean isQuoted;
+	private boolean isExplicit;
 
 	/**
 	 * Means to generate an {@link Identifier} instance from its simple text form.
@@ -286,4 +287,12 @@ public static Identifier quote(Identifier identifier) {
 	public int compareTo(Identifier identifier) {
 		return getCanonicalName().compareTo( identifier.getCanonicalName() );
 	}
+
+	public boolean isExplicit() {
+		return isExplicit;
+	}
+
+	public void setExplicit(boolean isExplicit) {
+		this.isExplicit = isExplicit;
+	}
 }

hibernate-core/src/main/java/org/hibernate/boot/spi/InFlightMetadataCollector.java

@@ -150,7 +150,8 @@ Table addTable(
 			String name,
 			String subselect,
 			boolean isAbstract,
-			MetadataBuildingContext buildingContext);
+			MetadataBuildingContext buildingContext,
+			boolean isExplicit);
 
 	/**
 	 * Adds a 'denormalized table' to this repository.

hibernate-core/src/main/java/org/hibernate/id/enhanced/SequenceStyleGenerator.java

@@ -352,10 +352,12 @@ private static QualifiedName sequenceName(
 			IdentifierHelper identifierHelper) {
 		if ( isNotEmpty( explicitSequenceName ) ) {
 			// we have an explicit name, use it
-			return explicitSequenceName.contains(".")
+			QualifiedNameParser.NameParts nameParts = explicitSequenceName.contains( "." )
 					? QualifiedNameParser.INSTANCE.parse( explicitSequenceName )
 					: new QualifiedNameParser.NameParts( catalog, schema,
 							identifierHelper.toIdentifier( explicitSequenceName ) );
+			nameParts.getObjectName().setExplicit( true );
+			return nameParts;
 		}
 		else {
 			// otherwise, determine an implicit name to use

hibernate-core/src/test/java/org/hibernate/orm/test/associations/ExplicitIdentifierTest.java

@@ -0,0 +1,133 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.orm.test.associations;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.Id;
+import jakarta.persistence.SequenceGenerator;
+import jakarta.persistence.Table;
+import org.hibernate.boot.model.naming.Identifier;
+import org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl;
+import org.hibernate.cfg.AvailableSettings;
+import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
+import org.hibernate.testing.orm.junit.DomainModel;
+import org.hibernate.testing.orm.junit.JiraKey;
+import org.hibernate.testing.orm.junit.ServiceRegistry;
+import org.hibernate.testing.orm.junit.SessionFactory;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+import org.hibernate.testing.orm.junit.Setting;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+
+import static jakarta.persistence.GenerationType.SEQUENCE;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@SessionFactory
+@DomainModel(annotatedClasses = {
+		ExplicitIdentifierTest.PersonExplicit.class,
+		ExplicitIdentifierTest.PersonImplicit.class
+})
+@ServiceRegistry(
+		settings = {
+				@Setting(name = AvailableSettings.PHYSICAL_NAMING_STRATEGY,
+						value = "org.hibernate.orm.test.associations.ExplicitIdentifierTest$CustomPhysicalNamingStrategy")
+		}
+)
+@JiraKey("HHH-14584")
+public class ExplicitIdentifierTest {
+
+	@Test
+	void testExplicitIdentifier(SessionFactoryScope scope) {
+
+		scope.inTransaction( session -> {
+			PersonImplicit personImplicit = new PersonImplicit();
+			personImplicit.name = "implicit";
+			session.persist( personImplicit );
+
+			PersonExplicit personExplicit = new PersonExplicit();
+			personExplicit.name = "explicit";
+			session.persist( personExplicit );
+		} );
+
+		scope.inTransaction( session -> {
+
+			// implicit named objects have a prefix
+			assertEquals( "implicit", session.createNativeQuery(
+							"select COLUMN_name from TABLE_ExplicitIdentifierTest$PersonImplicit",
+							String.class )
+					.getSingleResult() );
+			assertEquals( 51, session.createNativeQuery(
+					"select nextval('SEQUENCE_TABLE_ExplicitIdentifierTest$PersonImplicit_SEQ')",
+					Integer.class ).getSingleResult() );
+
+			// explicit named object don't have a prefix
+			assertEquals( "explicit", session.createNativeQuery(
+							"select name from PersonExplicit",
+							String.class )
+					.getSingleResult() );
+			assertEquals( 51, session.createNativeQuery(
+					"select nextval('person_explicit_seq')",
+					Integer.class ).getSingleResult() );
+		} );
+	}
+
+	@AfterAll
+	public void dropTestData(SessionFactoryScope scope) {
+		scope.dropData();
+	}
+
+	@Entity
+	public static class PersonImplicit {
+
+		@Id
+		@GeneratedValue
+		long id;
+
+		@Column
+		String name;
+	}
+
+	@Entity
+	@Table(name = "PersonExplicit")
+	public static class PersonExplicit {
+
+		@Id
+		@GeneratedValue(
+				strategy = SEQUENCE,
+				generator = "person_sequence"
+		)
+		@SequenceGenerator(name = "person_sequence", sequenceName = "person_explicit_seq")
+		long id;
+
+		@Column(name = "name")
+		String name;
+	}
+
+	public static class CustomPhysicalNamingStrategy extends PhysicalNamingStrategyStandardImpl {
+
+		@Override
+		public Identifier toPhysicalTableName(Identifier logicalName, JdbcEnvironment jdbcEnvironment) {
+			return logicalName.isExplicit() ? logicalName
+					: jdbcEnvironment.getIdentifierHelper().toIdentifier( "TABLE_" + logicalName,
+							logicalName.isQuoted() );
+		}
+
+		@Override
+		public Identifier toPhysicalSequenceName(Identifier logicalName, JdbcEnvironment jdbcEnvironment) {
+			return logicalName.isExplicit() ? logicalName
+					: jdbcEnvironment.getIdentifierHelper().toIdentifier( "SEQUENCE_" + logicalName,
+							logicalName.isQuoted() );
+		}
+
+		@Override
+		public Identifier toPhysicalColumnName(Identifier logicalName, JdbcEnvironment jdbcEnvironment) {
+			return logicalName.isExplicit() ? logicalName
+					: jdbcEnvironment.getIdentifierHelper().toIdentifier( "COLUMN_" + logicalName,
+							logicalName.isQuoted() );
+		}
+	}
+}

hibernate-testing/src/main/java/org/hibernate/testing/orm/junit/DialectFeatureChecks.java

@@ -1247,7 +1247,8 @@ public Table addTable(
 				String name,
 				String subselect,
 				boolean isAbstract,
-				MetadataBuildingContext buildingContext) {
+				MetadataBuildingContext buildingContext,
+				boolean isExplicit) {
 			return null;
 		}