Revert "HHH-19976 Don't adopt AdjustableBasicType name to create derived type"

This reverts commit 4328313.

Author: sebersole

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

@@ -68,7 +68,7 @@ public static <T> BasicValue.Resolution<T> from(
 		final var typeConfiguration = bootstrapContext.getTypeConfiguration();
 		final var basicTypeRegistry = typeConfiguration.getBasicTypeRegistry();
 
-		final JavaType<T> reflectedJtd;
+		final var reflectedJtd = reflectedJtdResolver.get();
 
 		// NOTE: the distinction that is made below wrt `explicitJavaType` and `reflectedJtd`
 		//       is needed temporarily to trigger "legacy resolution" versus "ORM6 resolution.
@@ -110,7 +110,7 @@ else if ( explicitJdbcType != null ) {
 				}
 			}
 		}
-		else if ( ( reflectedJtd = reflectedJtdResolver.get() ) != null ) {
+		else if ( reflectedJtd != null ) {
 			// we were able to determine the "reflected java-type"
 			// Use JTD if we know it to apply any specialized resolutions
 			if ( reflectedJtd instanceof EnumJavaType enumJavaType ) {
@@ -150,7 +150,7 @@ else if ( explicitJdbcType != null ) {
 
 				if ( registeredType != null ) {
 					// so here is the legacy resolution
-					jdbcMapping = resolveSqlTypeIndicators( stdIndicators, registeredType, registeredType.getJavaTypeDescriptor() );
+					jdbcMapping = resolveSqlTypeIndicators( stdIndicators, registeredType, reflectedJtd );
 				}
 				else {
 					// there was not a "legacy" BasicType registration,
@@ -311,11 +311,7 @@ private static <T,E> BasicType<T> pluralBasicType(
 					pluralJavaType.resolveType(
 							bootstrapContext.getTypeConfiguration(),
 							dialect,
-							resolveSqlTypeIndicators(
-									stdIndicators,
-									registeredElementType,
-									registeredElementType.getJavaTypeDescriptor()
-							),
+							resolveSqlTypeIndicators( stdIndicators, registeredElementType, elementJavaType ),
 							selectable instanceof ColumnTypeInformation information ? information : null,
 							stdIndicators
 					);

hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/MetadataBuildingProcess.java

@@ -762,7 +762,7 @@ public void contributeType(CompositeUserType<?> type) {
 		}
 
 		final int preferredSqlTypeCodeForDuration = getPreferredSqlTypeCodeForDuration( serviceRegistry );
-		if ( preferredSqlTypeCodeForDuration != SqlTypes.DURATION ) {
+		if ( preferredSqlTypeCodeForDuration != SqlTypes.INTERVAL_SECOND ) {
 			adaptToPreferredSqlTypeCode(
 					typeConfiguration,
 					jdbcTypeRegistry,
@@ -772,6 +772,9 @@ public void contributeType(CompositeUserType<?> type) {
 					"org.hibernate.type.DurationType"
 			);
 		}
+		else {
+			addFallbackIfNecessary( jdbcTypeRegistry, SqlTypes.INTERVAL_SECOND, SqlTypes.DURATION );
+		}
 
 		addFallbackIfNecessary( jdbcTypeRegistry, SqlTypes.INET, SqlTypes.VARBINARY );
 		addFallbackIfNecessary( jdbcTypeRegistry, SqlTypes.GEOMETRY, SqlTypes.VARBINARY );

hibernate-core/src/main/java/org/hibernate/type/AdjustableBasicType.java

@@ -25,16 +25,16 @@ default <X> BasicType<X> resolveIndicatedType(JdbcTypeIndicators indicators, Jav
 					indicators,
 					domainJtd
 			);
-			if ( getJavaTypeDescriptor() != domainJtd || resolvedJdbcType != jdbcType ) {
+			if ( resolvedJdbcType != jdbcType ) {
 				return indicators.getTypeConfiguration().getBasicTypeRegistry()
-						.resolve( domainJtd, resolvedJdbcType );
+						.resolve( domainJtd, resolvedJdbcType, getName() );
 			}
 		}
 		else {
 			final int resolvedJdbcTypeCode = indicators.resolveJdbcTypeCode( jdbcType.getDefaultSqlTypeCode() );
-			if ( getJavaTypeDescriptor() != domainJtd || resolvedJdbcTypeCode != jdbcType.getDefaultSqlTypeCode() ) {
+			if ( resolvedJdbcTypeCode != jdbcType.getDefaultSqlTypeCode() ) {
 				return indicators.getTypeConfiguration().getBasicTypeRegistry()
-						.resolve( domainJtd, indicators.getJdbcType( resolvedJdbcTypeCode ) );
+						.resolve( domainJtd, indicators.getJdbcType( resolvedJdbcTypeCode ), getName() );
 			}
 		}
 		return (BasicType<X>) this;

hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java

@@ -5,8 +5,6 @@
 package org.hibernate.type;
 
 import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
@@ -51,7 +49,6 @@ public class BasicTypeRegistry implements Serializable {
 
 	private final Map<String, BasicType<?>> typesByName = new ConcurrentHashMap<>();
 	private final Map<String, BasicTypeReference<?>> typeReferencesByName = new ConcurrentHashMap<>();
-	private final Map<String, List<BasicTypeReference<?>>> typeReferencesByJavaTypeName = new ConcurrentHashMap<>();
 
 	public BasicTypeRegistry(TypeConfiguration typeConfiguration){
 		this.typeConfiguration = typeConfiguration;
@@ -259,28 +256,14 @@ private <J> BasicType<J> createIfUnregistered(
 		if ( registeredTypeMatches( javaType, jdbcType, registeredType ) ) {
 			return castNonNull( registeredType );
 		}
-		// Create an ad-hoc type since the java type doesn't come from the registry and is probably explicitly defined
-		else if ( typeConfiguration.getJavaTypeRegistry().resolveDescriptor( javaType.getJavaType() ) == javaType ) {
-			final var basicTypeReferences = typeReferencesByJavaTypeName.get( javaType.getTypeName() );
-			if ( basicTypeReferences != null && !basicTypeReferences.isEmpty() ) {
-				final var jdbcTypeRegistry = typeConfiguration.getJdbcTypeRegistry();
-				for ( var typeReference : basicTypeReferences ) {
-					if ( jdbcTypeRegistry.getDescriptor( typeReference.getSqlTypeCode() ) == jdbcType ) {
-						final var basicType = typesByName.get( typeReference.getName() );
-						//noinspection unchecked
-						return registeredTypeMatches( javaType, jdbcType, basicType )
-								? (BasicType<J>) basicType
-								: (BasicType<J>) createBasicType( typeReference.getName(), typeReference );
-					}
-				}
-			}
+		else {
+			final var createdType = creator.get();
+			register( javaType, jdbcType, createdType );
+			return createdType;
 		}
-		final var createdType = creator.get();
-		register( javaType, jdbcType, createdType );
-		return createdType;
 	}
 
-	private static boolean registeredTypeMatches(JavaType<?> javaType, JdbcType jdbcType, @Nullable BasicType<?> registeredType) {
+	private static <J> boolean registeredTypeMatches(JavaType<J> javaType, JdbcType jdbcType, BasicType<J> registeredType) {
 		return registeredType != null
 			&& registeredType.getJdbcType() == jdbcType
 			&& registeredType.getMappedJavaType() == javaType;
@@ -351,7 +334,7 @@ public void addTypeReferenceRegistrationKey(String typeReferenceKey, String... a
 			throw new IllegalArgumentException( "Couldn't find type reference with name: " + typeReferenceKey );
 		}
 		for ( String additionalTypeReferenceKey : additionalTypeReferenceKeys ) {
-			addTypeReference( additionalTypeReferenceKey, basicTypeReference );
+			typeReferencesByName.put( additionalTypeReferenceKey, basicTypeReference );
 		}
 	}
 
@@ -401,7 +384,7 @@ public void addPrimeEntry(BasicTypeReference<?> type, String legacyTypeClassName
 
 		// Legacy name registration
 		if ( isNotEmpty( legacyTypeClassName ) ) {
-			addTypeReference( legacyTypeClassName, type );
+			typeReferencesByName.put( legacyTypeClassName, type );
 		}
 
 		// explicit registration keys
@@ -446,31 +429,19 @@ private void applyRegistrationKeys(BasicTypeReference<?> type, String[] keys) {
 				// Incidentally, this might also help with map lookup efficiency.
 				key = key.intern();
 
-				addTypeReference( key, type );
-			}
-		}
-	}
-
-	private void addTypeReference(String name, BasicTypeReference<?> typeReference) {
-		// Incredibly verbose logging disabled
-//		LOG.tracef( "Adding type registration %s -> %s", key, type );
+				// Incredibly verbose logging disabled
+//				LOG.tracef( "Adding type registration %s -> %s", key, type );
 
 //				final BasicTypeReference<?> old =
-				typeReferencesByName.put( name, typeReference );
-//		if ( old != null && old != type ) {
-//			LOG.tracef(
-//					"Type registration key [%s] overrode previous entry : `%s`",
-//					key,
-//					old
-//			);
-//		}
-
-		final var basicTypeReferences = typeReferencesByJavaTypeName.computeIfAbsent(
-				typeReference.getJavaType().getTypeName(),
-				s -> new ArrayList<>()
-		);
-		if ( !basicTypeReferences.contains( typeReference ) ) {
-			basicTypeReferences.add( typeReference );
+				typeReferencesByName.put( key, type );
+//				if ( old != null && old != type ) {
+//					LOG.tracef(
+//							"Type registration key [%s] overrode previous entry : `%s`",
+//							key,
+//							old
+//					);
+//				}
+			}
 		}
 	}
 }

hibernate-core/src/main/java/org/hibernate/type/StandardBasicTypes.java

@@ -345,12 +345,13 @@ private StandardBasicTypes() {
 	// Date / time data
 
 	/**
-	 * The standard Hibernate type for mapping {@link Duration} to JDBC {@link org.hibernate.type.SqlTypes#DURATION DURATION}.
+	 * The standard Hibernate type for mapping {@link Duration} to JDBC {@link org.hibernate.type.SqlTypes#INTERVAL_SECOND INTERVAL_SECOND}
+	 * or {@link org.hibernate.type.SqlTypes#NUMERIC NUMERIC} as a fallback.
 	 */
 	public static final BasicTypeReference<Duration> DURATION = new BasicTypeReference<>(
 			"Duration",
 			Duration.class,
-			SqlTypes.DURATION
+			SqlTypes.INTERVAL_SECOND
 	);
 
 	/**

hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/DurationMappingTests.java

@@ -16,8 +16,6 @@
 import org.hibernate.metamodel.mapping.internal.BasicAttributeMapping;
 import org.hibernate.metamodel.spi.MappingMetamodelImplementor;
 import org.hibernate.persister.entity.EntityPersister;
-import org.hibernate.testing.orm.junit.DialectFeatureChecks;
-import org.hibernate.testing.orm.junit.RequiresDialectFeature;
 import org.hibernate.type.SqlTypes;
 import org.hibernate.type.descriptor.jdbc.AdjustableJdbcType;
 import org.hibernate.type.descriptor.jdbc.JdbcType;
@@ -46,7 +44,6 @@
  * 	2.2.21. Duration
  * 		By default, Hibernate maps Duration to the NUMERIC SQL type.
  */
-@RequiresDialectFeature(feature = DialectFeatureChecks.SupportsIntervalSecondType.class)
 @ServiceRegistry(settings = @Setting(name = AvailableSettings.PREFERRED_DURATION_JDBC_TYPE, value = "INTERVAL_SECOND"))
 public class DurationMappingTests {
 

hibernate-envers/src/test/java/org/hibernate/orm/test/envers/integration/basic/NationalizedTest.java

@@ -1113,12 +1113,6 @@ public boolean apply(Dialect dialect) {
 		}
 	}
 
-	public static class SupportsIntervalSecondType implements DialectFeatureCheck {
-		public boolean apply(Dialect dialect) {
-			return definesDdlType( dialect, SqlTypes.INTERVAL_SECOND );
-		}
-	}
-
 	public static class SupportsVectorType implements DialectFeatureCheck {
 		public boolean apply(Dialect dialect) {
 			return definesDdlType( dialect, SqlTypes.VECTOR );