HHH-16311 - Migrate enum handling away from UserType

Author: sebersole

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

@@ -7,11 +7,11 @@
 package org.hibernate.boot.model.process.internal;
 
 import org.hibernate.mapping.BasicValue;
-import org.hibernate.metamodel.mapping.JdbcMapping;
-import org.hibernate.type.EnumType;
-import org.hibernate.type.descriptor.converter.spi.EnumValueConverter;
 import org.hibernate.type.BasicType;
+import org.hibernate.type.ConvertedBasicType;
 import org.hibernate.type.CustomType;
+import org.hibernate.type.EnumType;
+import org.hibernate.type.descriptor.converter.spi.EnumValueConverter;
 import org.hibernate.type.descriptor.java.EnumJavaType;
 import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan;
 import org.hibernate.type.descriptor.java.JavaType;
@@ -21,50 +21,36 @@
 import org.hibernate.type.spi.TypeConfiguration;
 
 /**
+ * Resolution for {@linkplain Enum enum} mappings
+ *
  * @author Steve Ebersole
  */
 public class EnumeratedValueResolution<E extends Enum<E>,R> implements BasicValue.Resolution<E> {
-	private final JdbcMapping jdbcMapping;
-
-	private final EnumJavaType<E> domainJtd;
-	private final JavaType<R> jdbcJtd;
-	private final JdbcType jdbcType;
 	private final EnumValueConverter<E,R> valueConverter;
 
+	private final ConvertedBasicType<E> jdbcMapping;
 	private final CustomType<E> legacyTypeResolution;
 
 	public EnumeratedValueResolution(
-			EnumJavaType<E> domainJtd,
-			JavaType<R> jdbcJtd,
 			JdbcType jdbcType,
 			EnumValueConverter<E, R> valueConverter,
 			TypeConfiguration typeConfiguration) {
-		this.domainJtd = domainJtd;
-		this.jdbcJtd = jdbcJtd;
-		this.jdbcType = jdbcType;
 		this.valueConverter = valueConverter;
 
-		this.jdbcMapping = buildJdbcMapping( domainJtd, jdbcType, valueConverter, typeConfiguration );
-		this.legacyTypeResolution = new CustomType<>(
-				new EnumType<>( domainJtd.getJavaTypeClass(), valueConverter, typeConfiguration ),
-				typeConfiguration
-		);
-	}
-
-	private JdbcMapping buildJdbcMapping(
-			JavaType<E> domainJtd,
-			JdbcType jdbcType,
-			EnumValueConverter<E, R> valueConverter,
-			TypeConfiguration typeConfiguration) {
-		return new ConvertedBasicTypeImpl<>(
-				domainJtd.getJavaTypeClass().getName(),
+		final EnumJavaType<E> domainJavaType = valueConverter.getDomainJavaType();
+		this.jdbcMapping = new ConvertedBasicTypeImpl<>(
+				domainJavaType.getJavaTypeClass().getName(),
 				jdbcType,
 				valueConverter
 		);
+		this.legacyTypeResolution = new CustomType<>(
+				new EnumType<>( domainJavaType.getJavaTypeClass(), valueConverter, typeConfiguration ),
+				typeConfiguration
+		);
 	}
 
 	@Override
-	public JdbcMapping getJdbcMapping() {
+	public ConvertedBasicType<E> getJdbcMapping() {
 		return jdbcMapping;
 	}
 
@@ -75,17 +61,17 @@ public BasicType getLegacyResolvedBasicType() {
 
 	@Override
 	public JavaType<E> getDomainJavaType() {
-		return domainJtd;
+		return jdbcMapping.getJavaTypeDescriptor();
 	}
 
 	@Override
 	public JavaType<?> getRelationalJavaType() {
-		return jdbcJtd;
+		return jdbcMapping.getJdbcJavaType();
 	}
 
 	@Override
 	public JdbcType getJdbcType() {
-		return jdbcType;
+		return jdbcMapping.getJdbcType();
 	}
 
 	@Override

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

@@ -12,6 +12,7 @@
 import java.util.function.Supplier;
 
 import org.hibernate.MappingException;
+import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.dialect.Dialect;
 import org.hibernate.mapping.BasicValue;
 import org.hibernate.mapping.Column;
@@ -20,14 +21,12 @@
 import org.hibernate.tool.schema.extract.spi.ColumnTypeInformation;
 import org.hibernate.type.AdjustableBasicType;
 import org.hibernate.type.BasicType;
-import org.hibernate.type.CustomType;
 import org.hibernate.type.SerializableType;
 import org.hibernate.type.descriptor.converter.internal.NamedEnumValueConverter;
 import org.hibernate.type.descriptor.converter.internal.OrdinalEnumValueConverter;
 import org.hibernate.type.descriptor.java.BasicJavaType;
 import org.hibernate.type.descriptor.java.BasicPluralJavaType;
 import org.hibernate.type.descriptor.java.EnumJavaType;
-import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan;
 import org.hibernate.type.descriptor.java.JavaType;
 import org.hibernate.type.descriptor.java.JavaTypeHelper;
 import org.hibernate.type.descriptor.java.MutabilityPlan;
@@ -61,8 +60,10 @@ public static <T> BasicValue.Resolution<T> from(
 			Selectable selectable,
 			String ownerName,
 			String propertyName,
-			Dialect dialect,
-			TypeConfiguration typeConfiguration) {
+			MetadataBuildingContext buildingContext) {
+		final Dialect dialect = buildingContext.getMetadataCollector().getDatabase().getDialect();
+		final TypeConfiguration typeConfiguration = buildingContext.getBootstrapContext().getTypeConfiguration();
+
 		final JavaType<T> reflectedJtd = reflectedJtdResolver.get();
 
 		// NOTE : the distinction that is made below wrt `explicitJavaType` and `reflectedJtd` is
@@ -162,14 +163,14 @@ else if ( explicitJdbcType != null ) {
 					final JavaType<?> elementJtd = containerJtd.getElementJavaType();
 					final BasicType registeredElementType;
 					if ( elementJtd instanceof EnumJavaType ) {
-						final EnumeratedValueResolution resolution = InferredBasicValueResolver.fromEnum(
-								(EnumJavaType) elementJtd,
+						final EnumeratedValueResolution<?,?> resolution = InferredBasicValueResolver.fromEnum(
+								(EnumJavaType<?>) elementJtd,
 								null,
 								null,
 								stdIndicators,
 								typeConfiguration
 						);
-						registeredElementType = resolution.getLegacyResolvedBasicType();
+						registeredElementType = resolution.getJdbcMapping();
 					}
 					else if ( JavaTypeHelper.isTemporal( elementJtd ) ) {
 						final InferredBasicValueResolution resolution = InferredBasicValueResolver.fromTemporal(
@@ -352,6 +353,11 @@ public static <E extends Enum<E>, R> EnumeratedValueResolution<E,R> fromEnum(
 		}
 
 		if ( enumStyle == null ) {
+			// NOTE : separate from the explicit ORDINAL check to facilitate
+			// handling native database enum types.  In theory anyway - atm
+			// we cannot discern an implicit (default value) or explicit style
+			// due to HCANN and annotation handling for default values
+
 			//noinspection unchecked
 			return (EnumeratedValueResolution<E, R>) ordinalEnumValueResolution(
 					enumJavaType,
@@ -375,8 +381,6 @@ private static <E extends Enum<E>, N extends Number> EnumeratedValueResolution<E
 		final JdbcType jdbcType = ordinalJdbcType( explicitJdbcType, enumJavaType, typeConfiguration );
 
 		return new EnumeratedValueResolution<>(
-				enumJavaType,
-				relationalJavaType,
 				jdbcType,
 				new OrdinalEnumValueConverter<>( enumJavaType, jdbcType, relationalJavaType ),
 				typeConfiguration
@@ -405,29 +409,6 @@ private static <N extends Number> JavaType<N> ordinalJavaType(JavaType<N> explic
 		}
 	}
 
-	private static <E extends Enum<E>, N extends Number> InferredBasicValueResolution<E, N> ordinalResolution(
-			EnumJavaType<E> enumJavaType,
-			JavaType<N> relationalJtd,
-			JdbcType jdbcType,
-			TypeConfiguration typeConfiguration) {
-		final CustomType<E> customType = new CustomType<>(
-				new org.hibernate.type.EnumType<>(
-						enumJavaType.getJavaTypeClass(),
-						new OrdinalEnumValueConverter<>( enumJavaType, jdbcType, relationalJtd ),
-						typeConfiguration
-				),
-				typeConfiguration
-		);
-		return new InferredBasicValueResolution<>(
-				customType,
-				enumJavaType,
-				relationalJtd,
-				jdbcType,
-				customType,
-				ImmutableMutabilityPlan.instance()
-		);
-	}
-
 	private static <E extends Enum<E>> EnumeratedValueResolution<E,String> stringEnumValueResolution(
 			EnumJavaType<E> enumJavaType,
 			BasicJavaType<?> explicitJavaType,
@@ -438,8 +419,6 @@ private static <E extends Enum<E>> EnumeratedValueResolution<E,String> stringEnu
 		final JdbcType jdbcType = stringJdbcType( explicitJdbcType, stdIndicators, relationalJtd );
 
 		return new EnumeratedValueResolution<>(
-				enumJavaType,
-				relationalJtd,
 				jdbcType,
 				new NamedEnumValueConverter<>( enumJavaType, jdbcType, relationalJtd ),
 				typeConfiguration

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

@@ -485,8 +485,7 @@ public TypeConfiguration getTypeConfiguration() {
 					column,
 					ownerName,
 					propertyName,
-					getDialect(),
-					getTypeConfiguration()
+					getBuildingContext()
 			);
 		}
 	}