HHH-19247 Add ordinal() also to Type contributions to be able to influence the order in which serviceloaded custom types are registered

Author: kad-barens

hibernate-core/src/main/java/org/hibernate/boot/model/FunctionContributor.java

@@ -31,34 +31,16 @@
  *     or even {@link org.hibernate.boot.MetadataBuilder#applyFunctions(FunctionContributor)}.
  * </ul>
  *
- * @see org.hibernate.query.sqm.function.SqmFunctionRegistry
- *
  * @author Karel Maesen
+ * @see org.hibernate.query.sqm.function.SqmFunctionRegistry
  */
 @JavaServiceLoadable
-public interface FunctionContributor {
+public interface FunctionContributor extends Ordinated {
 
 	/**
 	 * Contribute functions
 	 *
 	 * @param functionContributions The target for the contributions
 	 */
 	void contributeFunctions(FunctionContributions functionContributions);
-
-	/**
-	 * Determines order in which the contributions will be applied
-	 * (lowest ordinal first).
-	 * <p>
-	 * The range 0-500 is reserved for Hibernate, range 500-1000 for libraries and
-	 * 1000-Integer.MAX_VALUE for user-defined FunctionContributors.
-	 * <p>
-	 * Contributions from higher precedence contributors (higher numbers) effectively override 
-	 * contributions from lower precedence.  E.g. if a contributor with precedence 1000 contributes a 
-	 * function named {@code "max"}, that will override Hibernate's standard function of that name.
-	 *
-	 * @return the ordinal for this FunctionContributor
-	 */
-	default int ordinal(){
-		return 1000;
-	}
 }

hibernate-core/src/main/java/org/hibernate/boot/model/Ordinated.java

@@ -0,0 +1,32 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.boot.model;
+
+/**
+ * Interface that defines the loading order of a contribution
+ *
+ * @author Steven Barendregt
+ */
+public interface Ordinated {
+
+	/**
+	 * Determines order in which contributions will be applied
+	 * (lowest ordinal first).
+	 * <p>
+	 * The range 0-500 is reserved for Hibernate, range 500-1000 for libraries and
+	 * 1000-Integer.MAX_VALUE for user-defined Contributors.
+	 * <p>
+	 * Contributions from higher precedence contributors (higher numbers) effectively override
+	 * contributions from lower precedence.
+	 *
+	 * @return the ordinal for a Contributor
+	 */
+	default int ordinal() {
+		return 1000;
+	}
+
+}

hibernate-core/src/main/java/org/hibernate/boot/model/TypeContributor.java

@@ -23,17 +23,16 @@
  *     or even {@link org.hibernate.boot.MetadataBuilder#applyTypes(TypeContributor)}.
  * <li>
  *     When bootstrapping Hibernate via JPA or {@link org.hibernate.cfg.Configuration},
- *
+ * <p>
  *     Finally, in the JPA boostrap process, {@code TypeContributor}s may be
  *     listed via {@link org.hibernate.jpa.boot.spi.JpaSettings#TYPE_CONTRIBUTORS}.
  * </ul>
  *
  * @author Steve Ebersole
- *
  * @see org.hibernate.type.spi.TypeConfiguration
  */
 @JavaServiceLoadable
-public interface TypeContributor {
+public interface TypeContributor extends Ordinated {
 	/**
 	 * Contribute types
 	 *

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

@@ -87,6 +87,7 @@
 
 import jakarta.persistence.AttributeConverter;
 
+import static java.util.Comparator.comparingInt;
 import static org.hibernate.internal.util.config.ConfigurationHelper.getPreferredSqlTypeCodeForArray;
 import static org.hibernate.internal.util.config.ConfigurationHelper.getPreferredSqlTypeCodeForDuration;
 import static org.hibernate.internal.util.config.ConfigurationHelper.getPreferredSqlTypeCodeForInstant;
@@ -95,18 +96,18 @@
 /**
  * Represents the process of transforming a {@link MetadataSources}
  * reference into a {@link org.hibernate.boot.Metadata} reference.  Allows for 2 different process paradigms:<ul>
- *     <li>
- *         Single step : as defined by the {@link #build} method; internally leverages the 2-step paradigm
- *     </li>
- *     <li>
- *         Two step : a first step coordinates resource scanning and some other preparation work; a second step
- *         builds the {@link org.hibernate.boot.Metadata}.  A hugely important distinction in the need for the
- *         steps is that the first phase should strive to not load user entity/component classes so that we can still
- *         perform enhancement on them later.  This approach caters to the 2-phase bootstrap we use in regards
- *         to WildFly Hibernate-JPA integration.  The first step is defined by {@link #prepare} which returns
- *         a {@link ManagedResources} instance.  The second step is defined by calling
- *         {@link #complete}
- *     </li>
+ * <li>
+ * Single step : as defined by the {@link #build} method; internally leverages the 2-step paradigm
+ * </li>
+ * <li>
+ * Two step : a first step coordinates resource scanning and some other preparation work; a second step
+ * builds the {@link org.hibernate.boot.Metadata}.  A hugely important distinction in the need for the
+ * steps is that the first phase should strive to not load user entity/component classes so that we can still
+ * perform enhancement on them later.  This approach caters to the 2-phase bootstrap we use in regards
+ * to WildFly Hibernate-JPA integration.  The first step is defined by {@link #prepare} which returns
+ * a {@link ManagedResources} instance.  The second step is defined by calling
+ * {@link #complete}
+ * </li>
  * </ul>
  *
  * @author Steve Ebersole
@@ -199,7 +200,7 @@ public static MetadataImplementor complete(
 
 		final MetadataSourceProcessor processor = new MetadataSourceProcessor() {
 			private final MetadataSourceProcessor hbmProcessor =
-						options.isXmlMappingEnabled()
+					options.isXmlMappingEnabled()
 							? new HbmMetadataSourceProcessorImpl( managedResources, rootMetadataBuildingContext )
 							: new NoOpMetadataSourceProcessorImpl();
 
@@ -338,8 +339,19 @@ public void finishUp() {
 
 		processor.finishUp();
 
-		processAdditionalMappingContributions( metadataCollector, options, classLoaderService, rootMetadataBuildingContext );
-		processAdditionalJaxbMappingProducer( metadataCollector, options, jandexView, classLoaderService, rootMetadataBuildingContext );
+		processAdditionalMappingContributions(
+				metadataCollector,
+				options,
+				classLoaderService,
+				rootMetadataBuildingContext
+		);
+		processAdditionalJaxbMappingProducer(
+				metadataCollector,
+				options,
+				jandexView,
+				classLoaderService,
+				rootMetadataBuildingContext
+		);
 
 		applyExtraQueryImports( managedResources, metadataCollector );
 
@@ -379,7 +391,8 @@ public boolean transformHbmMappings() {
 				rootMetadataBuildingContext
 		);
 
-		final Collection<AdditionalMappingContributor> additionalMappingContributors = classLoaderService.loadJavaServices( AdditionalMappingContributor.class );
+		final Collection<AdditionalMappingContributor> additionalMappingContributors = classLoaderService.loadJavaServices(
+				AdditionalMappingContributor.class );
 		additionalMappingContributors.forEach( (contributor) -> {
 			contributions.setCurrentContributor( contributor.getContributorName() );
 			try {
@@ -450,7 +463,7 @@ public void contributeBinding(InputStream xmlStream) {
 
 		@Override
 		public void contributeBinding(JaxbEntityMappings mappingJaxbBinding) {
-			if ( ! options.isXmlMappingEnabled() ) {
+			if ( !options.isXmlMappingEnabled() ) {
 				return;
 			}
 
@@ -462,7 +475,7 @@ public void contributeBinding(JaxbEntityMappings mappingJaxbBinding) {
 
 		@Override
 		public void contributeBinding(JaxbHbmHibernateMapping hbmJaxbBinding) {
-			if ( ! options.isXmlMappingEnabled() ) {
+			if ( !options.isXmlMappingEnabled() ) {
 				return;
 			}
 
@@ -527,7 +540,8 @@ private static void processAdditionalJaxbMappingProducer(
 			ClassLoaderService classLoaderService,
 			MetadataBuildingContextRootImpl rootMetadataBuildingContext) {
 		if ( options.isXmlMappingEnabled() ) {
-			final Iterable<AdditionalJaxbMappingProducer> producers = classLoaderService.loadJavaServices( AdditionalJaxbMappingProducer.class );
+			final Iterable<AdditionalJaxbMappingProducer> producers = classLoaderService.loadJavaServices(
+					AdditionalJaxbMappingProducer.class );
 			if ( producers != null ) {
 				final EntityHierarchyBuilder hierarchyBuilder = new EntityHierarchyBuilder();
 				final MappingBinder mappingBinder = new MappingBinder(
@@ -597,7 +611,7 @@ private static void handleTypes(
 			MetadataBuildingOptions options,
 			InFlightMetadataCollector metadataCollector) {
 		final ClassLoaderService classLoaderService =
-				options.getServiceRegistry().requireService(ClassLoaderService.class);
+				options.getServiceRegistry().requireService( ClassLoaderService.class );
 
 		final TypeConfiguration typeConfiguration = bootstrapContext.getTypeConfiguration();
 		final StandardServiceRegistry serviceRegistry = bootstrapContext.getServiceRegistry();
@@ -631,7 +645,7 @@ public void contributeType(CompositeUserType<?> type) {
 			basicTypeRegistry.addTypeReferenceRegistrationKey(
 					StandardBasicTypes.BINARY_WRAPPER.getName(),
 					Byte[].class.getName(), "Byte[]"
-					);
+			);
 		}
 
 		// add Dialect contributed types
@@ -642,7 +656,7 @@ public void contributeType(CompositeUserType<?> type) {
 		final JdbcType dialectArrayDescriptor = jdbcTypeRegistry.findDescriptor( SqlTypes.ARRAY );
 
 		// add TypeContributor contributed types.
-		for ( TypeContributor contributor : classLoaderService.loadJavaServices( TypeContributor.class ) ) {
+		for ( TypeContributor contributor : sortedTypeContributors( classLoaderService ) ) {
 			contributor.contribute( typeContributions, options.getServiceRegistry() );
 		}
 
@@ -749,6 +763,17 @@ public void contributeType(CompositeUserType<?> type) {
 		}
 	}
 
+	private static List<TypeContributor> sortedTypeContributors(
+			ClassLoaderService classLoaderService) {
+		Collection<TypeContributor> typeContributors = classLoaderService.loadJavaServices( TypeContributor.class );
+		List<TypeContributor> contributors = new ArrayList<>( typeContributors );
+		contributors.sort(
+				comparingInt( TypeContributor::ordinal )
+						.thenComparing( a -> a.getClass().getCanonicalName() )
+		);
+		return contributors;
+	}
+
 	private static void adaptToPreferredSqlTypeCode(
 			JdbcTypeRegistry jdbcTypeRegistry,
 			JdbcType dialectUuidDescriptor,
@@ -830,7 +855,9 @@ private static void adaptTimestampTypesToDefaultTimeZoneStorage(
 		);
 	}
 
-	private static JdbcType getTimeWithTimeZoneOverride(MetadataBuildingOptions options, JdbcTypeRegistry jdbcTypeRegistry) {
+	private static JdbcType getTimeWithTimeZoneOverride(
+			MetadataBuildingOptions options,
+			JdbcTypeRegistry jdbcTypeRegistry) {
 		switch ( options.getDefaultTimeZoneStorage() ) {
 			case NORMALIZE:
 				// For NORMALIZE, we replace the standard types that use TIME_WITH_TIMEZONE to use TIME
@@ -843,7 +870,9 @@ private static JdbcType getTimeWithTimeZoneOverride(MetadataBuildingOptions opti
 		}
 	}
 
-	private static JdbcType getTimestampWithTimeZoneOverride(MetadataBuildingOptions options, JdbcTypeRegistry jdbcTypeRegistry) {
+	private static JdbcType getTimestampWithTimeZoneOverride(
+			MetadataBuildingOptions options,
+			JdbcTypeRegistry jdbcTypeRegistry) {
 		switch ( options.getDefaultTimeZoneStorage() ) {
 			case NORMALIZE:
 				// For NORMALIZE, we replace the standard types that use TIMESTAMP_WITH_TIMEZONE to use TIMESTAMP

hibernate-core/src/test/java/org/hibernate/orm/test/type/contributor/usertype/TypeContributionOrdinalTest.java

@@ -0,0 +1,77 @@
+package org.hibernate.orm.test.type.contributor.usertype;
+
+import org.hibernate.boot.model.TypeContributions;
+import org.hibernate.boot.model.TypeContributor;
+import org.hibernate.service.ServiceRegistry;
+
+import org.hibernate.testing.orm.junit.BootstrapServiceRegistry;
+import org.hibernate.testing.orm.junit.DomainModel;
+import org.hibernate.testing.orm.junit.Jira;
+import org.hibernate.testing.orm.junit.SessionFactory;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+
+import org.hibernate.type.descriptor.jdbc.VarcharJdbcType;
+import org.hibernate.type.spi.TypeConfiguration;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test to assert that service loaded types are processed in ascending ordinal order
+ *
+ * @author Steven Barendregt
+ */
+@DomainModel
+@SessionFactory
+@BootstrapServiceRegistry(
+		javaServices = {
+				@BootstrapServiceRegistry.JavaService(role = TypeContributor.class, impl = TypeContributionOrdinalTest.HigherOrdinalServiceLoadedVarcharTypeContributor.class),
+				@BootstrapServiceRegistry.JavaService(role = TypeContributor.class, impl = TypeContributionOrdinalTest.ServiceLoadedVarcharTypeContributor.class)
+		}
+)
+public class TypeContributionOrdinalTest {
+
+	@Test
+	@Jira(value = "https://hibernate.atlassian.net/issues/HHH-19247")
+	public void testHigherOrdinalServiceLoadedCustomUserTypeTakesPrecedence(SessionFactoryScope scope) {
+		final TypeConfiguration typeConfigurations = scope.getSessionFactory()
+				.getMappingMetamodel()
+				.getTypeConfiguration();
+		Assertions.assertInstanceOf(
+				HigherOrdinalServiceLoadedVarcharTypeContributor.HigherOrdinalExtendedVarcharJdbcType.class,
+				typeConfigurations.getJdbcTypeRegistry().findDescriptor( 12 )
+		);
+	}
+
+	public static class ServiceLoadedVarcharTypeContributor implements TypeContributor {
+
+		@Override
+		public void contribute(TypeContributions typeContributions, ServiceRegistry serviceRegistry) {
+			typeContributions.contributeJdbcType( ExtendedVarcharJdbcType.INSTANCE );
+		}
+
+		public static class ExtendedVarcharJdbcType extends VarcharJdbcType {
+
+			public static final ExtendedVarcharJdbcType INSTANCE = new ExtendedVarcharJdbcType();
+		}
+
+	}
+
+	public static class HigherOrdinalServiceLoadedVarcharTypeContributor implements TypeContributor {
+
+		@Override
+		public void contribute(TypeContributions typeContributions, ServiceRegistry serviceRegistry) {
+			typeContributions.contributeJdbcType( HigherOrdinalExtendedVarcharJdbcType.INSTANCE );
+		}
+
+		@Override
+		public int ordinal() {
+			return 2000;
+		}
+
+		public static class HigherOrdinalExtendedVarcharJdbcType extends VarcharJdbcType {
+
+			public static final HigherOrdinalExtendedVarcharJdbcType INSTANCE = new HigherOrdinalExtendedVarcharJdbcType();
+		}
+	}
+}