Implement support for CompositeUserType and re-enable tests that make use of it

Author: beikov

documentation/src/test/java/org/hibernate/userguide/mapping/basic/ColumnTransformerTest.java

@@ -11,12 +11,16 @@
 import java.util.Locale;
 
 import org.hibernate.annotations.ColumnTransformer;
+import org.hibernate.annotations.CompositeType;
 import org.hibernate.dialect.H2Dialect;
 import org.hibernate.orm.test.jpa.BaseEntityManagerFunctionalTestCase;
 
 import org.hibernate.testing.RequiresDialect;
 import org.junit.Test;
 
+import jakarta.persistence.AttributeOverride;
+import jakarta.persistence.AttributeOverrides;
+import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.Id;
 
@@ -43,15 +47,14 @@ public void testLifecycle() {
 			//tag::basic-datetime-temporal-date-persist-example[]
 			Savings savings = new Savings();
 			savings.setId(1L);
-			savings.setCurrency(Currency.getInstance(Locale.US));
-			savings.setAmount(BigDecimal.TEN);
+			savings.setWallet(new MonetaryAmount(BigDecimal.TEN, Currency.getInstance(Locale.US)));
 			entityManager.persist(savings);
 		});
 
 		doInJPA(this::entityManagerFactory, entityManager -> {
 			Savings savings = entityManager.find(Savings.class, 1L);
-			assertEquals(10, savings.getAmount().intValue());
-			assertEquals(Currency.getInstance(Locale.US), savings.getCurrency());
+			assertEquals(10, savings.getWallet().getAmount().intValue());
+			assertEquals(Currency.getInstance(Locale.US), savings.getWallet().getCurrency());
 		});
 		//end::mapping-column-read-and-write-composite-type-persistence-example[]
 	}
@@ -63,12 +66,17 @@ public static class Savings {
 		@Id
 		private Long id;
 
+		@CompositeType(MonetaryAmountUserType.class)
+		@AttributeOverrides({
+			@AttributeOverride(name = "amount", column = @Column(name = "money")),
+			@AttributeOverride(name = "currency", column = @Column(name = "currency"))
+		})
 		@ColumnTransformer(
-				read = "amount / 100",
+				forColumn = "money",
+				read = "money / 100",
 				write = "? * 100"
 		)
-		private BigDecimal amount;
-		private Currency currency;
+		private MonetaryAmount wallet;
 
 		//Getters and setters omitted for brevity
 
@@ -81,20 +89,12 @@ public void setId(Long id) {
 			this.id = id;
 		}
 
-		public BigDecimal getAmount() {
-			return amount;
+		public MonetaryAmount getWallet() {
+			return wallet;
 		}
 
-		public void setAmount(BigDecimal amount) {
-			this.amount = amount;
-		}
-
-		public Currency getCurrency() {
-			return currency;
-		}
-
-		public void setCurrency(Currency currency) {
-			this.currency = currency;
+		public void setWallet(MonetaryAmount wallet) {
+			this.wallet = wallet;
 		}
 
 

documentation/src/test/java/org/hibernate/userguide/mapping/basic/MonetaryAmountUserType.java

@@ -0,0 +1,96 @@
+/*
+ * 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.userguide.mapping.basic;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Currency;
+import java.util.function.Supplier;
+
+import org.hibernate.HibernateException;
+import org.hibernate.engine.spi.SessionFactoryImplementor;
+import org.hibernate.usertype.CompositeUserType;
+
+/**
+ * @author Emmanuel Bernard
+ */
+public class MonetaryAmountUserType implements CompositeUserType<MonetaryAmount> {
+
+	@Override
+	public Object getPropertyValue(MonetaryAmount component, int property) throws HibernateException {
+		switch ( property ) {
+			case 0:
+				return component.getAmount();
+			case 1:
+				return component.getCurrency();
+		}
+		throw new HibernateException( "Illegal property index: " + property );
+	}
+
+	@Override
+	public MonetaryAmount instantiate(Supplier<Object[]> valueSupplier, SessionFactoryImplementor sessionFactory) {
+		final Object[] values = valueSupplier.get();
+		return new MonetaryAmount( (BigDecimal) values[0], (Currency) values[1] );
+	}
+
+	@Override
+	public Class<?> embeddable() {
+		return MonetaryAmountEmbeddable.class;
+	}
+
+	@Override
+	public Class<MonetaryAmount> returnedClass() {
+		return MonetaryAmount.class;
+	}
+
+	@Override
+	public boolean isMutable() {
+		return true;
+	}
+
+	@Override
+	public Object deepCopy(Object value) {
+		MonetaryAmount ma = (MonetaryAmount) value;
+		return new MonetaryAmount( ma.getAmount(), ma.getCurrency() );
+	}
+
+	@Override
+	public boolean equals(Object x, Object y) {
+		if ( x == y ) {
+			return true;
+		}
+		if ( x == null || y == null ) {
+			return false;
+		}
+		return x.equals( y );
+	}
+
+	@Override
+	public Serializable disassemble(Object value) throws HibernateException {
+		return (Serializable) deepCopy( value );
+	}
+
+	@Override
+	public Object assemble(Serializable cached, Object owner) throws HibernateException {
+		return deepCopy( cached );
+	}
+
+	@Override
+	public Object replace(Object original, Object target, Object owner) throws HibernateException {
+		return deepCopy( original ); //TODO: improve
+	}
+
+	@Override
+	public int hashCode(Object x) throws HibernateException {
+		return x.hashCode();
+	}
+
+	public static class MonetaryAmountEmbeddable {
+		private BigDecimal amount;
+		private Currency currency;
+	}
+}

hibernate-core/src/main/java/org/hibernate/annotations/CompositeType.java

@@ -0,0 +1,28 @@
+/*
+ * 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.annotations;
+
+import java.lang.annotation.Retention;
+
+import org.hibernate.usertype.CompositeUserType;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * Applies a custom {@link CompositeUserType} for the attribute mapping.
+ */
+@java.lang.annotation.Target({METHOD, FIELD})
+@Retention(RUNTIME)
+public @interface CompositeType {
+
+	/**
+	 * The custom type implementor class
+	 */
+	Class<? extends CompositeUserType<?>> value();
+}

hibernate-core/src/main/java/org/hibernate/annotations/CompositeTypeRegistration.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.annotations;
+
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import org.hibernate.usertype.CompositeUserType;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.PACKAGE;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * Registers a custom composite user type implementation to be used
+ * for all references to a particular {@link jakarta.persistence.Embeddable}.
+ * <p/>
+ * May be overridden for a specific embedded using {@link org.hibernate.annotations.CompositeType}
+ */
+@Target( {TYPE, ANNOTATION_TYPE, PACKAGE} )
+@Retention( RUNTIME )
+@Repeatable( CompositeTypeRegistrations.class )
+public @interface CompositeTypeRegistration {
+	Class<?> embeddableClass();
+	Class<? extends CompositeUserType<?>> userType();
+}

hibernate-core/src/main/java/org/hibernate/annotations/CompositeTypeRegistrations.java

@@ -0,0 +1,26 @@
+/*
+ * 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.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.PACKAGE;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * Grouping of {@link CompositeTypeRegistration}
+ *
+ * @author Steve Ebersole
+ */
+@Target( {TYPE, ANNOTATION_TYPE, PACKAGE} )
+@Retention( RUNTIME )
+public @interface CompositeTypeRegistrations {
+	CompositeTypeRegistration[] value();
+}

hibernate-core/src/main/java/org/hibernate/annotations/MapKeyCustomCompositeType.java

@@ -0,0 +1,23 @@
+/*
+ * 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.annotations;
+
+import org.hibernate.usertype.CompositeUserType;
+
+/**
+ * Form of {@link CompositeType} for use with map-keys
+ *
+ * @since 6.0
+ */
+public @interface MapKeyCustomCompositeType {
+	/**
+	 * The custom type implementor class
+	 *
+	 * @see CompositeType#value
+	 */
+	Class<? extends CompositeUserType<?>> value();
+}

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

@@ -104,6 +104,7 @@
 import org.hibernate.type.descriptor.java.JavaType;
 import org.hibernate.type.descriptor.jdbc.JdbcType;
 import org.hibernate.type.spi.TypeConfiguration;
+import org.hibernate.usertype.CompositeUserType;
 
 import jakarta.persistence.AttributeConverter;
 import jakarta.persistence.Embeddable;
@@ -410,6 +411,25 @@ public Class<? extends EmbeddableInstantiator> findRegisteredEmbeddableInstantia
 		return registeredInstantiators.get( embeddableType );
 	}
 
+	private Map<Class<?>, Class<? extends CompositeUserType<?>>> registeredCompositeUserTypes;
+
+	@Override
+	public void registerCompositeUserType(Class<?> embeddableType, Class<? extends CompositeUserType<?>> userType) {
+		if ( registeredCompositeUserTypes == null ) {
+			registeredCompositeUserTypes = new HashMap<>();
+		}
+		registeredCompositeUserTypes.put( embeddableType, userType );
+	}
+
+	@Override
+	public Class<? extends CompositeUserType<?>> findRegisteredCompositeUserType(Class<?> embeddableType) {
+		if ( registeredCompositeUserTypes == null ) {
+			return null;
+		}
+
+		return registeredCompositeUserTypes.get( embeddableType );
+	}
+
 	private Map<CollectionClassification, CollectionTypeRegistrationDescriptor> collectionTypeRegistrations;
 
 

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

@@ -153,6 +153,7 @@
 import org.hibernate.type.CustomType;
 import org.hibernate.type.ForeignKeyDirection;
 import org.hibernate.type.StandardBasicTypes;
+import org.hibernate.usertype.CompositeUserType;
 import org.hibernate.usertype.ParameterizedType;
 import org.hibernate.usertype.UserType;
 
@@ -2636,6 +2637,22 @@ else if ( isVirtual ) {
 		else {
 			log.debugf( "Binding component [%s]", role );
 			if ( StringHelper.isNotEmpty( explicitComponentClassName ) ) {
+				try {
+					final Class<Object> componentClass = sourceDocument.getBootstrapContext().getClassLoaderAccess()
+							.classForName( explicitComponentClassName );
+					if ( CompositeUserType.class.isAssignableFrom( componentClass ) ) {
+						componentBinding.setTypeName( explicitComponentClassName );
+						CompositeUserType<?> compositeUserType = (CompositeUserType<?>) sourceDocument.getBootstrapContext()
+								.getServiceRegistry()
+								.getService( ManagedBeanRegistry.class )
+								.getBean( componentClass )
+								.getBeanInstance();
+						explicitComponentClassName = compositeUserType.embeddable().getName();
+					}
+				}
+				catch (ClassLoadingException ex) {
+					log.debugf( ex, "Could load component class [%s]", explicitComponentClassName );
+				}
 				log.debugf( "Binding component [%s] to explicitly specified class", role, explicitComponentClassName );
 				componentBinding.setComponentClassName( explicitComponentClassName );
 			}

hibernate-core/src/main/java/org/hibernate/boot/query/HbmResultSetMappingDescriptor.java

@@ -653,11 +653,11 @@ public FetchMemento resolve(ResultSetMappingResolutionContext resolutionContext)
 
 			final FetchParentMemento fetchParentMemento = parent.resolveParentMemento( resolutionContext );
 
-			NavigablePath navigablePath = fetchParentMemento.getNavigablePath().append( propertyPathParts[ 0 ] );
 			Fetchable fetchable = (Fetchable) fetchParentMemento.getFetchableContainer().findSubPart(
 					propertyPathParts[ 0 ],
 					null
 			);
+			NavigablePath navigablePath = fetchParentMemento.getNavigablePath().append( fetchable.getFetchableName() );
 
 			for ( int i = 1; i < propertyPathParts.length; i++ ) {
 				if ( ! ( fetchable instanceof FetchableContainer ) ) {
@@ -666,8 +666,8 @@ public FetchMemento resolve(ResultSetMappingResolutionContext resolutionContext)
 									+ " did not reference FetchableContainer"
 					);
 				}
-				navigablePath = navigablePath.append( propertyPathParts[ i ] );
 				fetchable = (Fetchable) ( (FetchableContainer) fetchable ).findSubPart( propertyPathParts[i], null );
+				navigablePath = navigablePath.append( fetchable.getFetchableName() );
 			}
 
 			if ( fetchable instanceof BasicValuedModelPart ) {