From 9a6f5f48663b8626bd292f77804b9bde0ec727bf Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sat, 6 Sep 2025 10:04:33 +0200 Subject: [PATCH 1/7] simplification to CollectionJavaType --- .../java/spi/CollectionJavaType.java | 96 +++++++++---------- 1 file changed, 43 insertions(+), 53 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java index 75e66ce4a9d4..b7d792b33f47 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java @@ -51,49 +51,34 @@ public JdbcType getRecommendedJdbcType(JdbcTypeIndicators context) { return null; } - @Override + @Override @SuppressWarnings({"unchecked", "rawtypes"}) public JavaType createJavaType( ParameterizedType parameterizedType, TypeConfiguration typeConfiguration) { - final Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); - final var javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); - switch ( semantics.getCollectionClassification() ) { - case ARRAY: - //noinspection unchecked - return (JavaType) new ArrayJavaType<>( - javaTypeRegistry.resolveDescriptor( - ( (Class) parameterizedType.getRawType() ).getComponentType() - ) - ); - case BAG: - case ID_BAG: - case LIST: - case SET: - case SORTED_SET: - case ORDERED_SET: - //noinspection unchecked,rawtypes - return new BasicCollectionJavaType( - parameterizedType, - javaTypeRegistry.resolveDescriptor( actualTypeArguments[actualTypeArguments.length - 1] ), - semantics - ); - - } - // Construct a basic java type that knows its parametrization - //noinspection unchecked,rawtypes - return new UnknownBasicJavaType( - parameterizedType, - new MapMutabilityPlan<>( - (MapSemantics, Object, Object>) semantics, - javaTypeRegistry.resolveDescriptor( actualTypeArguments[0] ), - javaTypeRegistry.resolveDescriptor( actualTypeArguments[actualTypeArguments.length - 1] ) - ) - ); - } - - @Override - public C fromString(CharSequence string) { - throw new UnsupportedOperationException(); + final Type[] typeArguments = parameterizedType.getActualTypeArguments(); + final var registry = typeConfiguration.getJavaTypeRegistry(); + return switch ( semantics.getCollectionClassification() ) { + case ARRAY -> { + final var arrayClass = (Class) parameterizedType.getRawType(); + yield (JavaType) new ArrayJavaType<>( registry.resolveDescriptor( arrayClass.getComponentType() ) ); + } + case BAG, ID_BAG, LIST, SET, SORTED_SET, ORDERED_SET -> + new BasicCollectionJavaType( + parameterizedType, + registry.resolveDescriptor( typeArguments[typeArguments.length-1] ), + semantics + ); + case MAP, ORDERED_MAP, SORTED_MAP -> + // Construct a basic java type that knows its parametrization + new UnknownBasicJavaType( + parameterizedType, + new MapMutabilityPlan( + (MapSemantics) semantics, + registry.resolveDescriptor( typeArguments[0] ), + registry.resolveDescriptor( typeArguments[typeArguments.length-1] ) + ) + ); + }; } @Override @@ -111,16 +96,20 @@ public boolean areEqual(C one, C another) { if ( one == another ) { return true; } - - if ( one instanceof PersistentCollection pc ) { - return pc.wasInitialized() && ( pc.isWrapper( another ) || pc.isDirectlyProvidedCollection( another ) ); + else if ( one instanceof PersistentCollection collection ) { + return wraps( collection, another ); } - - if ( another instanceof PersistentCollection pc ) { - return pc.wasInitialized() && ( pc.isWrapper( one ) || pc.isDirectlyProvidedCollection( one ) ); + else if ( another instanceof PersistentCollection collection ) { + return wraps( collection, one ); } + else { + return Objects.equals( one, another ); + } + } - return Objects.equals( one, another ); + private static boolean wraps(PersistentCollection collection, C other) { + return collection.wasInitialized() + && collection.isWrapper( other ); } @Override @@ -153,13 +142,14 @@ public C deepCopy(C value) { if ( value == null ) { return null; } - final C copy = semantics.instantiateRaw( value.size(), null ); - - for ( var entry : value.entrySet() ) { - copy.put( keyPlan.deepCopy( entry.getKey() ), - valuePlan.deepCopy( entry.getValue() ) ); + else { + final C copy = semantics.instantiateRaw( value.size(), null ); + for ( var entry : value.entrySet() ) { + copy.put( keyPlan.deepCopy( entry.getKey() ), + valuePlan.deepCopy( entry.getValue() ) ); + } + return copy; } - return copy; } @Override From aa4b98bb05d3b4fbed3e36a5bfaa534dfb4e2cb4 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sat, 6 Sep 2025 11:39:41 +0200 Subject: [PATCH 2/7] fix generic typing to in BasicCollectionJavaType --- .../ast/internal/MultiKeyLoadHelper.java | 22 +-- .../internal/CollectionConverter.java | 46 ++--- .../java/spi/BasicCollectionJavaType.java | 160 ++++++++++-------- .../descriptor/java/spi/JavaTypeRegistry.java | 2 +- 4 files changed, 129 insertions(+), 101 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiKeyLoadHelper.java b/hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiKeyLoadHelper.java index 0ecd0ff37f4e..5c6bbd5d45b1 100644 --- a/hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiKeyLoadHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiKeyLoadHelper.java @@ -9,9 +9,6 @@ import org.hibernate.metamodel.mapping.JdbcMapping; import org.hibernate.type.BasicType; import org.hibernate.type.descriptor.java.BasicPluralJavaType; -import org.hibernate.type.descriptor.java.JavaType; -import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; -import org.hibernate.type.spi.TypeConfiguration; import java.util.Arrays; @@ -30,18 +27,21 @@ public static JdbcMapping resolveArrayJdbcMapping( JdbcMapping keyMapping, Class elementClass, SessionFactoryImplementor sessionFactory) { - BasicType arrayBasicType = sessionFactory.getTypeConfiguration().getBasicTypeRegistry() - .getRegisteredArrayType( elementClass ); + final var arrayBasicType = + sessionFactory.getTypeConfiguration().getBasicTypeRegistry() + .getRegisteredArrayType( elementClass ); if ( arrayBasicType != null ) { return arrayBasicType; } - final TypeConfiguration typeConfiguration = sessionFactory.getTypeConfiguration(); - final JavaTypeRegistry javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); + final var typeConfiguration = sessionFactory.getTypeConfiguration(); + final var javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); - final JavaType rawArrayJavaType = javaTypeRegistry.resolveArrayDescriptor( elementClass ); + final var rawArrayJavaType = javaTypeRegistry.resolveArrayDescriptor( elementClass ); if ( !(rawArrayJavaType instanceof BasicPluralJavaType arrayJavaType ) ) { - throw new IllegalArgumentException( "Expecting BasicPluralJavaType for array class `" + elementClass.getTypeName() + "[]`, but got `" + rawArrayJavaType + "`" ); + throw new IllegalArgumentException( "Expecting BasicPluralJavaType for array class '" + + elementClass.getTypeName() + "[]', but got '" + + rawArrayJavaType + "'" ); } //noinspection unchecked,rawtypes @@ -79,6 +79,8 @@ static Object[] trimIdBatch(int length, Object[] keysToInitialize) { while ( newLength>1 && keysToInitialize[newLength-1] == null ) { newLength--; } - return newLength < length ? Arrays.copyOf(keysToInitialize, newLength) : keysToInitialize; + return newLength < length + ? Arrays.copyOf(keysToInitialize, newLength) + : keysToInitialize; } } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/CollectionConverter.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/CollectionConverter.java index c1f540136688..f165d00c9dca 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/CollectionConverter.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/CollectionConverter.java @@ -4,7 +4,6 @@ */ package org.hibernate.type.descriptor.converter.internal; -import java.lang.reflect.Array; import java.util.Collection; import org.hibernate.internal.build.AllowReflection; @@ -12,53 +11,58 @@ import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.java.spi.BasicCollectionJavaType; +import static java.lang.reflect.Array.newInstance; + /** * Handles conversion to/from a collection of a converted element type. */ -public class CollectionConverter, Y> implements BasicValueConverter { +public class CollectionConverter, E, R> implements BasicValueConverter { - private final BasicValueConverter elementConverter; + private final BasicValueConverter elementConverter; private final BasicCollectionJavaType domainJavaType; - private final JavaType relationalJavaType; + private final JavaType relationalJavaType; public CollectionConverter( - BasicValueConverter elementConverter, - BasicCollectionJavaType domainJavaType, - JavaType relationalJavaType) { + BasicValueConverter elementConverter, + BasicCollectionJavaType domainJavaType, + JavaType relationalJavaType) { this.elementConverter = elementConverter; this.domainJavaType = domainJavaType; this.relationalJavaType = relationalJavaType; } @Override - public X toDomainValue(Y relationalForm) { + public X toDomainValue(R[] relationalForm) { if ( relationalForm == null ) { return null; } - final Object[] relationalArray = (Object[]) relationalForm; - final X domainForm = domainJavaType.getSemantics().instantiateRaw( relationalArray.length, null ); - for ( int i = 0; i < relationalArray.length; i++ ) { - domainForm.add( elementConverter.toDomainValue( relationalArray[i] ) ); + final X domainForm = + domainJavaType.getSemantics() + .instantiateRaw( relationalForm.length, null ); + for ( R r : relationalForm ) { + domainForm.add( elementConverter.toDomainValue( r ) ); } return domainForm; } @Override - @AllowReflection - public Y toRelationalValue(X domainForm) { + public R[] toRelationalValue(X domainForm) { if ( domainForm == null ) { return null; } - final Object[] relationalArray = (Object[]) Array.newInstance( - elementConverter.getRelationalJavaType().getJavaTypeClass(), - domainForm.size() - ); + final R[] relationalArray = newRelationalArray( domainForm.size() ); int i = 0; - for ( Object domainValue : domainForm ) { + for ( var domainValue : domainForm ) { relationalArray[i++] = elementConverter.toRelationalValue( domainValue ); } + return relationalArray; + } + + @AllowReflection + private R[] newRelationalArray(int size) { + final Object result = newInstance( elementConverter.getRelationalJavaType().getJavaTypeClass(), size ); //noinspection unchecked - return (Y) relationalArray; + return (R[]) result; } @Override @@ -67,7 +71,7 @@ public JavaType getDomainJavaType() { } @Override - public JavaType getRelationalJavaType() { + public JavaType getRelationalJavaType() { return relationalJavaType; } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/BasicCollectionJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/BasicCollectionJavaType.java index 4e5ffce5e0dc..c0206a382371 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/BasicCollectionJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/BasicCollectionJavaType.java @@ -4,15 +4,6 @@ */ package org.hibernate.type.descriptor.java.spi; -import java.io.Serializable; -import java.lang.reflect.Array; -import java.lang.reflect.ParameterizedType; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Iterator; -import java.util.LinkedHashSet; - import org.hibernate.HibernateException; import org.hibernate.Incubating; import org.hibernate.MappingException; @@ -29,9 +20,9 @@ import org.hibernate.type.BasicCollectionType; import org.hibernate.type.BasicPluralType; import org.hibernate.type.BasicType; -import org.hibernate.type.descriptor.converter.internal.CollectionConverter; import org.hibernate.type.ConvertedBasicCollectionType; import org.hibernate.type.descriptor.WrapperOptions; +import org.hibernate.type.descriptor.converter.internal.CollectionConverter; import org.hibernate.type.descriptor.converter.spi.BasicValueConverter; import org.hibernate.type.descriptor.java.AbstractJavaType; import org.hibernate.type.descriptor.java.BasicPluralJavaType; @@ -41,6 +32,19 @@ import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators; import org.hibernate.type.spi.TypeConfiguration; +import java.io.Serializable; +import java.lang.reflect.ParameterizedType; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashSet; + +import static java.lang.reflect.Array.get; +import static java.lang.reflect.Array.getLength; +import static java.lang.reflect.Array.newInstance; +import static java.lang.reflect.Array.set; + + /** * Descriptor for handling persistent collections. * @@ -48,8 +52,9 @@ */ @Incubating @AllowReflection // Needed for arbitrary array wrapping/unwrapping -public class BasicCollectionJavaType, E> extends AbstractJavaType implements - BasicPluralJavaType { +public class BasicCollectionJavaType, E> + extends AbstractJavaType + implements BasicPluralJavaType { private final CollectionSemantics semantics; private final JavaType componentJavaType; @@ -102,71 +107,87 @@ public BasicType resolveType( BasicType elementType, ColumnTypeInformation columnTypeInformation, JdbcTypeIndicators stdIndicators) { - final JavaType elementJavaType = elementType.getJavaTypeDescriptor(); - final Class elementJavaTypeClass = elementJavaType.getJavaTypeClass(); + final var elementJavaType = elementType.getJavaTypeDescriptor(); + final var elementJavaTypeClass = elementJavaType.getJavaTypeClass(); if ( elementType instanceof BasicPluralType || elementJavaTypeClass != null && elementJavaTypeClass.isArray() ) { return null; } - final BasicCollectionJavaType collectionJavaType; - if ( componentJavaType == elementJavaType) { - collectionJavaType = this; - } - else { - collectionJavaType = new BasicCollectionJavaType<>( - (ParameterizedType) getJavaType(), - elementJavaType, - semantics - ); - // Register the collection type as that will be resolved in the next step - typeConfiguration.getJavaTypeRegistry().addDescriptor( collectionJavaType ); - } - final BasicValueConverter valueConverter = elementType.getValueConverter(); - final int arrayTypeCode = stdIndicators.getPreferredSqlTypeCodeForArray( elementType.getJdbcType().getDefaultSqlTypeCode() ); + final var collectionJavaType = collectionJavaType( typeConfiguration, elementJavaType ); + final int elementSqlTypeCode = elementType.getJdbcType().getDefaultSqlTypeCode(); + final int arrayTypeCode = stdIndicators.getPreferredSqlTypeCodeForArray( elementSqlTypeCode ); final var arrayJdbcType = typeConfiguration.getJdbcTypeRegistry() .resolveTypeConstructorDescriptor( arrayTypeCode, elementType, columnTypeInformation ); + final var valueConverter = elementType.getValueConverter(); if ( valueConverter == null ) { - return typeConfiguration.getBasicTypeRegistry().resolve( - collectionJavaType, - arrayJdbcType, - () -> new BasicCollectionType<>( elementType, arrayJdbcType, collectionJavaType ) - ); + return typeConfiguration.getBasicTypeRegistry() + .resolve( collectionJavaType, arrayJdbcType, + () -> new BasicCollectionType<>( elementType, arrayJdbcType, collectionJavaType ) ); } else { - final Class arrayClass = - Array.newInstance( valueConverter.getRelationalJavaType().getJavaTypeClass(), 0 ) - .getClass(); - final JavaType relationalJavaType = - typeConfiguration.getJavaTypeRegistry().resolveDescriptor( arrayClass ); - //noinspection unchecked,rawtypes - return new ConvertedBasicCollectionType( + return convertedCollectionType( + typeConfiguration, elementType, arrayJdbcType, collectionJavaType, - new CollectionConverter( valueConverter, collectionJavaType, relationalJavaType ) + valueConverter ); } } + private static , E, R> ConvertedBasicCollectionType convertedCollectionType( + TypeConfiguration typeConfiguration, + BasicType elementType, + JdbcType arrayJdbcType, + BasicCollectionJavaType collectionJavaType, + BasicValueConverter elementValueConverter) { + final var elementRelationalJavaType = elementValueConverter.getRelationalJavaType(); + final var relationalJavaType = + typeConfiguration.getJavaTypeRegistry() + .resolveArrayDescriptor( elementRelationalJavaType.getJavaTypeClass() ); + return new ConvertedBasicCollectionType<>( + elementType, + arrayJdbcType, + collectionJavaType, + new CollectionConverter<>( elementValueConverter, collectionJavaType, relationalJavaType ) + ); + } + + private BasicCollectionJavaType collectionJavaType( + TypeConfiguration typeConfiguration, + JavaType elementJavaType) { + if ( componentJavaType == elementJavaType ) { + return this; + } + else { + final var parameterizedType = (ParameterizedType) getJavaType(); + final var collectionJavaType = + new BasicCollectionJavaType<>( parameterizedType, elementJavaType, semantics ); + // Register the collection type as that will be resolved in the next step + typeConfiguration.getJavaTypeRegistry().addDescriptor( collectionJavaType ); + return collectionJavaType; + } + } + @Override public String extractLoggableRepresentation(C value) { if ( value == null ) { return "null"; } - final Iterator iterator = value.iterator(); + final var iterator = value.iterator(); if ( !iterator.hasNext() ) { return "[]"; } - final StringBuilder sb = new StringBuilder(); - sb.append( '[' ); + final var string = new StringBuilder(); + string.append( '[' ); do { final E element = iterator.next(); - sb.append( componentJavaType.extractLoggableRepresentation( element ) ); + string.append( componentJavaType.extractLoggableRepresentation( element ) ); if ( !iterator.hasNext() ) { - return sb.append( ']' ).toString(); + return string.append( ']' ).toString(); } - sb.append( ", " ); + string.append( ", " ); } while ( true ); } @@ -186,8 +207,8 @@ public boolean areEqual(C one, C another) { case LIST: case ORDERED_SET: case SORTED_SET: - final Iterator iterator1 = one.iterator(); - final Iterator iterator2 = another.iterator(); + final var iterator1 = one.iterator(); + final var iterator2 = another.iterator(); while ( iterator1.hasNext() ) { if ( !componentJavaType.areEqual( iterator1.next(), iterator2.next() ) ) { return false; @@ -225,32 +246,32 @@ public String toString(C value) { if ( value == null ) { return null; } - final StringBuilder sb = new StringBuilder(); - sb.append( '{' ); + final var string = new StringBuilder(); + string.append( '{' ); String glue = ""; for ( E v : value ) { - sb.append( glue ); + string.append( glue ); if ( v == null ) { - sb.append( "null" ); + string.append( "null" ); glue = ","; continue; } - sb.append( '"' ); - String valstr = this.componentJavaType.toString( v ); + string.append( '"' ); + String valstr = componentJavaType.toString( v ); // using replaceAll is a shorter, but much slower way to do this for (int i = 0, len = valstr.length(); i < len; i ++ ) { char c = valstr.charAt( i ); // Surrogate pairs. This is how they're done. if (c == '\\' || c == '"') { - sb.append( '\\' ); + string.append( '\\' ); } - sb.append( c ); + string.append( c ); } - sb.append( '"' ); + string.append( '"' ); glue = ","; } - sb.append( '}' ); - return sb.toString(); + string.append( '}' ); + return string.toString(); } @Override @@ -351,8 +372,8 @@ else if ( type == Object[].class ) { return (X) value.toArray(); } else if ( Object[].class.isAssignableFrom( type ) ) { - final Class preferredJavaTypeClass = type.getComponentType(); - final Object[] unwrapped = (Object[]) Array.newInstance( preferredJavaTypeClass, value.size() ); + final var preferredJavaTypeClass = type.getComponentType(); + final Object[] unwrapped = (Object[]) newInstance( preferredJavaTypeClass, value.size() ); int i = 0; for ( E element : value ) { unwrapped[i] = componentJavaType.unwrap( element, preferredJavaTypeClass, options ); @@ -362,12 +383,12 @@ else if ( Object[].class.isAssignableFrom( type ) ) { return (X) unwrapped; } else if ( type.isArray() ) { - final Class preferredJavaTypeClass = type.getComponentType(); + final var preferredJavaTypeClass = type.getComponentType(); //noinspection unchecked - final X unwrapped = (X) Array.newInstance( preferredJavaTypeClass, value.size() ); + final X unwrapped = (X) newInstance( preferredJavaTypeClass, value.size() ); int i = 0; for ( E element : value ) { - Array.set( unwrapped, i, componentJavaType.unwrap( element, preferredJavaTypeClass, options ) ); + set( unwrapped, i, componentJavaType.unwrap( element, preferredJavaTypeClass, options ) ); i++; } return unwrapped; @@ -395,7 +416,8 @@ public C wrap(X value, WrapperOptions options) { if ( value instanceof Object[] raw ) { final C wrapped = semantics.instantiateRaw( raw.length, null ); - if ( componentJavaType.getJavaTypeClass().isAssignableFrom( value.getClass().getComponentType() ) ) { + if ( componentJavaType.getJavaTypeClass() + .isAssignableFrom( value.getClass().getComponentType() ) ) { for ( Object o : raw ) { //noinspection unchecked wrapped.add( (E) o ); @@ -423,10 +445,10 @@ else if ( value instanceof Collection ) { return fromCollection( (Collection) value, options ); } else if ( value.getClass().isArray() ) { - final int length = Array.getLength( value ); + final int length = getLength( value ); final C wrapped = semantics.instantiateRaw( length, null ); for ( int i = 0; i < length; i++ ) { - wrapped.add( componentJavaType.wrap( Array.get( value, i ), options ) ); + wrapped.add( componentJavaType.wrap( get( value, i ), options ) ); } return wrapped; } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java index a7c9e2929926..1fdd8227cee0 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java @@ -128,7 +128,7 @@ private static MutabilityPlan createMutabilityPlan(Type elementJavaType, return MutableMutabilityPlan.INSTANCE; } - public JavaType resolveArrayDescriptor(Class elementJavaType) { + public JavaType resolveArrayDescriptor(Class elementJavaType) { return resolveDescriptor( elementJavaType.getTypeName() + "[]", () -> createArrayTypeDescriptor( elementJavaType, JavaTypeRegistry::createMutabilityPlan) ); } From d1b3430c59101d802742a40aad1a1d1641d75624 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sat, 6 Sep 2025 11:45:07 +0200 Subject: [PATCH 3/7] very minor cleanups --- .../descriptor/java/IncomparableComparator.java | 1 - .../java/spi/EmbeddableAggregateJavaType.java | 13 +++++++------ .../type/descriptor/java/spi/EntityJavaType.java | 6 +++--- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/IncomparableComparator.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/IncomparableComparator.java index 384ad60e42de..43e3b318666a 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/IncomparableComparator.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/IncomparableComparator.java @@ -15,7 +15,6 @@ public class IncomparableComparator implements Comparator { public static final IncomparableComparator INSTANCE = new IncomparableComparator(); @Override - @SuppressWarnings("ComparatorMethodParameterNotUsed") public int compare(Object o1, Object o2) { return 0; } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EmbeddableAggregateJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EmbeddableAggregateJavaType.java index b663bf081193..5d0822514db8 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EmbeddableAggregateJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EmbeddableAggregateJavaType.java @@ -34,13 +34,13 @@ public String getStructName() { @Override public JdbcType getRecommendedJdbcType(JdbcTypeIndicators context) { - final BasicType basicType = context.getTypeConfiguration().getBasicTypeForJavaType( getJavaType() ); + final var basicType = context.getTypeConfiguration().getBasicTypeForJavaType( getJavaType() ); if ( basicType != null ) { return basicType.getJdbcType(); } if ( structName != null ) { - final JdbcTypeRegistry jdbcTypeRegistry = context.getTypeConfiguration().getJdbcTypeRegistry(); - final AggregateJdbcType aggregateDescriptor = jdbcTypeRegistry.findAggregateDescriptor( structName ); + final var jdbcTypeRegistry = context.getTypeConfiguration().getJdbcTypeRegistry(); + final var aggregateDescriptor = jdbcTypeRegistry.findAggregateDescriptor( structName ); if ( aggregateDescriptor != null ) { return aggregateDescriptor; } @@ -49,9 +49,10 @@ public JdbcType getRecommendedJdbcType(JdbcTypeIndicators context) { } } // When the column is mapped as XML array, the component type must be SQLXML - if ( context.getExplicitJdbcTypeCode() != null && context.getExplicitJdbcTypeCode() == SqlTypes.XML_ARRAY - // Also prefer XML is the Dialect prefers XML arrays - || context.getDialect().getPreferredSqlTypeCodeForArray() == SqlTypes.XML_ARRAY ) { + final Integer explicitJdbcTypeCode = context.getExplicitJdbcTypeCode(); + if ( explicitJdbcTypeCode != null && explicitJdbcTypeCode == SqlTypes.XML_ARRAY + // Also prefer XML as the Dialect prefers XML arrays + || context.getDialect().getPreferredSqlTypeCodeForArray() == SqlTypes.XML_ARRAY ) { final var descriptor = context.getJdbcType( SqlTypes.SQLXML ); if ( descriptor != null ) { return descriptor; diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java index 98437761c624..37cc267e61a4 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java @@ -44,11 +44,11 @@ public boolean areEqual(T one, T another) { @Override public boolean isInstance(Object value) { - final LazyInitializer lazyInitializer = extractLazyInitializer( value ); - final Class javaTypeClass = getJavaTypeClass(); + final var lazyInitializer = extractLazyInitializer( value ); + final var javaTypeClass = getJavaTypeClass(); if ( lazyInitializer != null ) { return javaTypeClass.isAssignableFrom( lazyInitializer.getPersistentClass() ) - || javaTypeClass.isAssignableFrom( lazyInitializer.getImplementationClass() ); + || javaTypeClass.isAssignableFrom( lazyInitializer.getImplementationClass() ); } else { return javaTypeClass.isAssignableFrom( value.getClass() ); From 2979b275cd1c2d083ff95be0156a0ac175a98131 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sat, 6 Sep 2025 12:10:56 +0200 Subject: [PATCH 4/7] fix up some generic typing issues in the JavaTypes --- .../internal/EnumeratedValueConverter.java | 2 +- .../internal/InferredBasicValueResolver.java | 4 ++-- .../java/AbstractClassJavaType.java | 19 ++++++++--------- .../java/AbstractTemporalJavaType.java | 10 ++++----- .../java/ComponentArrayComparator.java | 8 +++---- .../descriptor/java/JdbcDateJavaType.java | 15 +++++++++---- .../descriptor/java/JdbcTimeJavaType.java | 21 ++++++++++++------- .../java/JdbcTimestampJavaType.java | 21 ++++++++++++------- .../descriptor/java/ObjectArrayJavaType.java | 10 ++++----- .../java/spi/CollectionJavaType.java | 2 +- .../java/spi/EmbeddableAggregateJavaType.java | 3 --- .../descriptor/java/spi/EntityJavaType.java | 1 - .../java/spi/FormatMapperBasedJavaType.java | 2 +- 13 files changed, 67 insertions(+), 51 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/EnumeratedValueConverter.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/EnumeratedValueConverter.java index 4e2a6090afb7..b2af94e883be 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/EnumeratedValueConverter.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/EnumeratedValueConverter.java @@ -36,7 +36,7 @@ public EnumeratedValueConverter( ensureAccessibility( valueField ); - final Class enumJavaTypeClass = enumJavaType.getJavaTypeClass(); + final var enumJavaTypeClass = enumJavaType.getJavaTypeClass(); final E[] enumConstants = enumJavaTypeClass.getEnumConstants(); relationalToEnumMap = mapOfSize( enumConstants.length ); enumToRelationalMap = mapOfSize( enumConstants.length ); diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java index cd635b94ecb9..cbf7b4a81660 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java @@ -404,8 +404,8 @@ private static > BasicType createEnumeratedValueJdbcMapping ); } - private static > Field determineEnumeratedValueField(Class enumJavaTypeClass) { - for ( Field field : enumJavaTypeClass.getDeclaredFields() ) { + private static > Field determineEnumeratedValueField(Class enumJavaTypeClass) { + for ( var field : enumJavaTypeClass.getDeclaredFields() ) { if ( field.isAnnotationPresent( EnumeratedValue.class ) ) { return field; } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractClassJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractClassJavaType.java index 95925042b7ff..58fdf1d6d20c 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractClassJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractClassJavaType.java @@ -34,7 +34,7 @@ public abstract class AbstractClassJavaType implements BasicJavaType, Seri * * @see #AbstractClassJavaType(Class, MutabilityPlan) */ - protected AbstractClassJavaType(Class type) { + protected AbstractClassJavaType(Class type) { this( type, ImmutableMutabilityPlan.instance() ); } @@ -44,12 +44,12 @@ protected AbstractClassJavaType(Class type) { * @param type The Java type. * @param mutabilityPlan The plan for handling mutability aspects of the java type. */ - protected AbstractClassJavaType(Class type, MutabilityPlan mutabilityPlan) { + protected AbstractClassJavaType(Class type, MutabilityPlan mutabilityPlan) { this( type, mutabilityPlan, Comparable.class.isAssignableFrom( type ) - ? ComparableComparator.instance() + ? ComparableComparator.INSTANCE : null ); } @@ -61,14 +61,13 @@ protected AbstractClassJavaType(Class type, MutabilityPlan type, - MutabilityPlan mutabilityPlan, - Comparator comparator) { - this.type = (Class) type; - this.mutabilityPlan = (MutabilityPlan) mutabilityPlan; - this.comparator = (Comparator) comparator; + Class type, + MutabilityPlan mutabilityPlan, + Comparator comparator) { + this.type = type; + this.mutabilityPlan = mutabilityPlan; + this.comparator = comparator; } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractTemporalJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractTemporalJavaType.java index 79c8c24ca7a0..d1a0079326ce 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractTemporalJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractTemporalJavaType.java @@ -17,18 +17,18 @@ public abstract class AbstractTemporalJavaType extends AbstractClassJavaType implements TemporalJavaType { - protected AbstractTemporalJavaType(Class type) { + protected AbstractTemporalJavaType(Class type) { super( type ); } - protected AbstractTemporalJavaType(Class type, MutabilityPlan mutabilityPlan) { + protected AbstractTemporalJavaType(Class type, MutabilityPlan mutabilityPlan) { super( type, mutabilityPlan ); } public AbstractTemporalJavaType( - Class type, - MutabilityPlan mutabilityPlan, - Comparator comparator) { + Class type, + MutabilityPlan mutabilityPlan, + Comparator comparator) { super( type, mutabilityPlan, comparator ); } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ComponentArrayComparator.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ComponentArrayComparator.java index e727ee78bc9c..0a62f1726b0d 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ComponentArrayComparator.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ComponentArrayComparator.java @@ -11,16 +11,16 @@ * * @author Christian Beikov */ -public class ComponentArrayComparator implements Comparator { +public class ComponentArrayComparator implements Comparator { - private final JavaType[] components; + private final JavaType[] components; - public ComponentArrayComparator(JavaType[] components) { + public ComponentArrayComparator(JavaType[] components) { this.components = components; } @Override - public int compare(Object[] o1, Object[] o2) { + public int compare(E[] o1, E[] o2) { for ( int i = 0; i < components.length; i++ ) { final int cmp = components[i].getComparator().compare( o1[i], o2[i] ); if ( cmp != 0 ) { diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcDateJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcDateJavaType.java index c23349d2ce80..a60835ae643b 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcDateJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcDateJavaType.java @@ -52,7 +52,7 @@ public class JdbcDateJavaType extends AbstractTemporalJavaType { .toFormatter(); public JdbcDateJavaType() { - super( java.sql.Date.class, DateMutabilityPlan.INSTANCE ); + super( Date.class, DateMutabilityPlan.INSTANCE ); } @Override @@ -60,6 +60,13 @@ public TemporalType getPrecision() { return TemporalType.DATE; } + @Override + public Class getJavaType() { + // wrong, but needed for backward compatibility + //noinspection unchecked, rawtypes + return (Class) java.sql.Date.class; + } + @Override public boolean isInstance(Object value) { // this check holds true for java.sql.Date as well @@ -135,9 +142,9 @@ public Object unwrap(Date value, Class type, WrapperOptions options) { } if ( Calendar.class.isAssignableFrom( type ) ) { - final GregorianCalendar cal = new GregorianCalendar(); - cal.setTimeInMillis( unwrapDateEpoch( value ) ); - return cal; + final var gregorianCalendar = new GregorianCalendar(); + gregorianCalendar.setTimeInMillis( unwrapDateEpoch( value ) ); + return gregorianCalendar; } if ( java.sql.Timestamp.class.isAssignableFrom( type ) ) { diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcTimeJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcTimeJavaType.java index 85154cdbe277..0ae67b8a4367 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcTimeJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcTimeJavaType.java @@ -52,7 +52,7 @@ public class JdbcTimeJavaType extends AbstractTemporalJavaType { public JdbcTimeJavaType() { - super( Time.class, TimeMutabilityPlan.INSTANCE ); + super( Date.class, TimeMutabilityPlan.INSTANCE ); } @Override @@ -60,6 +60,13 @@ public TemporalType getPrecision() { return TemporalType.TIME; } + @Override + public Class getJavaType() { + // wrong, but needed for backward compatibility + //noinspection unchecked, rawtypes + return (Class) java.sql.Time.class; + } + @Override public boolean isInstance(Object value) { // this check holds true for java.sql.Time as well @@ -69,7 +76,7 @@ public boolean isInstance(Object value) { @Override public int extractHashCode(Date value) { - final Calendar calendar = Calendar.getInstance(); + final var calendar = Calendar.getInstance(); calendar.setTime( value ); int hashCode = 1; hashCode = 31 * hashCode + calendar.get( Calendar.HOUR_OF_DAY ); @@ -118,9 +125,9 @@ public Object unwrap(Date value, Class type, WrapperOptions options) { if ( LocalTime.class.isAssignableFrom( type ) ) { final Time time = value instanceof java.sql.Time - ? ( (java.sql.Time) value ) + ? (java.sql.Time) value : new java.sql.Time( value.getTime() % 86_400_000 ); - final LocalTime localTime = time.toLocalTime(); + final var localTime = time.toLocalTime(); long millis = time.getTime() % 1000; if ( millis == 0 ) { return localTime; @@ -152,9 +159,9 @@ public Object unwrap(Date value, Class type, WrapperOptions options) { } if ( Calendar.class.isAssignableFrom( type ) ) { - final GregorianCalendar cal = new GregorianCalendar(); - cal.setTimeInMillis( value.getTime() ); - return cal; + final var gregorianCalendar = new GregorianCalendar(); + gregorianCalendar.setTimeInMillis( value.getTime() ); + return gregorianCalendar; } if ( java.sql.Timestamp.class.isAssignableFrom( type ) ) { diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcTimestampJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcTimestampJavaType.java index e7eb584c363f..601b91699397 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcTimestampJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/JdbcTimestampJavaType.java @@ -55,7 +55,14 @@ public class JdbcTimestampJavaType extends AbstractTemporalJavaType implem .withZone( ZoneId.from( ZoneOffset.UTC ) ); public JdbcTimestampJavaType() { - super( Timestamp.class, TimestampMutabilityPlan.INSTANCE ); + super( Date.class, TimestampMutabilityPlan.INSTANCE ); + } + + @Override + public Class getJavaType() { + // wrong, but needed for backward compatibility + //noinspection unchecked, rawtypes + return (Class) java.sql.Timestamp.class; } @Override @@ -105,7 +112,7 @@ public boolean areEqual(Date one, Date another) { @Override public int extractHashCode(Date value) { - return Long.valueOf( value.getTime() / 1000 ).hashCode(); + return Long.hashCode( value.getTime() / 1000 ); } @Override @@ -136,9 +143,9 @@ public Object unwrap(Date value, Class type, WrapperOptions options) { } if ( Calendar.class.isAssignableFrom( type ) ) { - final GregorianCalendar cal = new GregorianCalendar(); - cal.setTimeInMillis( value.getTime() ); - return cal; + final var gregorianCalendar = new GregorianCalendar(); + gregorianCalendar.setTimeInMillis( value.getTime() ); + return gregorianCalendar; } if ( Long.class.isAssignableFrom( type ) ) { @@ -147,13 +154,13 @@ public Object unwrap(Date value, Class type, WrapperOptions options) { if ( java.sql.Date.class.isAssignableFrom( type ) ) { return value instanceof java.sql.Date - ? ( java.sql.Date ) value + ? (java.sql.Date) value : new java.sql.Date( value.getTime() ); } if ( java.sql.Time.class.isAssignableFrom( type ) ) { return value instanceof java.sql.Time - ? ( java.sql.Time ) value + ? (java.sql.Time) value : new java.sql.Time( value.getTime() % 86_400_000 ); } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ObjectArrayJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ObjectArrayJavaType.java index 651f3bd1cab1..bdf4f8643bdc 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ObjectArrayJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ObjectArrayJavaType.java @@ -42,13 +42,13 @@ public String toString(Object[] value) { return sb.toString(); } - private void append(StringBuilder sb, JavaType[] components, Object[] value, int i) { - final Object o = value[i]; - if (o == null ) { - sb.append( "null" ); + private void append(StringBuilder builder, JavaType[] components, Object[] value, int i) { + final Object element = value[i]; + if (element == null ) { + builder.append( "null" ); } else { - sb.append( components[i].toString( o ) ); + builder.append( components[i].toString( element ) ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java index b7d792b33f47..30a55024836f 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java @@ -36,7 +36,7 @@ public class CollectionJavaType extends AbstractClassJavaType { private final CollectionSemantics semantics; - public CollectionJavaType(Class type, CollectionSemantics semantics) { + public CollectionJavaType(Class type, CollectionSemantics semantics) { super( type ); this.semantics = semantics; } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EmbeddableAggregateJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EmbeddableAggregateJavaType.java index 5d0822514db8..b5d5613c9fcb 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EmbeddableAggregateJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EmbeddableAggregateJavaType.java @@ -4,15 +4,12 @@ */ package org.hibernate.type.descriptor.java.spi; -import org.hibernate.type.BasicType; import org.hibernate.type.SqlTypes; import org.hibernate.type.descriptor.WrapperOptions; import org.hibernate.type.descriptor.java.AbstractClassJavaType; -import org.hibernate.type.descriptor.jdbc.AggregateJdbcType; import org.hibernate.type.descriptor.jdbc.JdbcType; import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators; import org.hibernate.type.descriptor.jdbc.internal.DelayedStructJdbcType; -import org.hibernate.type.descriptor.jdbc.spi.JdbcTypeRegistry; /** * Java type for embeddable aggregates, which allows resolving a recommended {@link JdbcType}. diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java index 37cc267e61a4..07114c69110f 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/EntityJavaType.java @@ -4,7 +4,6 @@ */ package org.hibernate.type.descriptor.java.spi; -import org.hibernate.proxy.LazyInitializer; import org.hibernate.type.descriptor.WrapperOptions; import org.hibernate.type.descriptor.java.AbstractClassJavaType; import org.hibernate.type.descriptor.java.IncomparableComparator; diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/FormatMapperBasedJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/FormatMapperBasedJavaType.java index ab757f0e56c3..e2dc208d72b7 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/FormatMapperBasedJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/FormatMapperBasedJavaType.java @@ -95,7 +95,7 @@ else if ( value instanceof String string ) { @Override public MutabilityPlan getMutabilityPlan() { - final MutabilityPlan mutabilityPlan = super.getMutabilityPlan(); + final var mutabilityPlan = super.getMutabilityPlan(); return mutabilityPlan == null ? this : mutabilityPlan; } From feec8ea4a3964586bde9aae3d28a07f6bb97b726 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sat, 6 Sep 2025 14:39:27 +0200 Subject: [PATCH 5/7] distinguish typesafe resolveDescriptor() from unsafe getDescriptor() --- .../hibernate/boot/model/TypeDefinition.java | 27 ++- .../internal/AbstractConverterDescriptor.java | 2 +- .../internal/ConverterDescriptorImpl.java | 7 +- .../convert/internal/ConverterHelper.java | 17 +- .../boot/model/internal/AnnotationHelper.java | 10 +- .../boot/model/internal/BasicValueBinder.java | 8 +- .../internal/InferredBasicValueResolver.java | 144 ++++++++------ .../internal/ManagedResourcesImpl.java | 2 +- .../internal/NamedConverterResolution.java | 36 ++-- .../process/internal/VersionResolution.java | 17 +- .../process/spi/MetadataBuildingProcess.java | 14 +- .../query/SqlResultSetMappingDescriptor.java | 5 +- .../hibernate/dialect/CockroachDialect.java | 2 +- .../org/hibernate/dialect/DB2Dialect.java | 2 +- .../org/hibernate/dialect/MySQLDialect.java | 2 +- .../org/hibernate/dialect/OracleDialect.java | 4 +- .../hibernate/dialect/PostgreSQLDialect.java | 2 +- .../org/hibernate/dialect/SybaseDialect.java | 4 +- .../dialect/function/array/DdlTypeHelper.java | 25 +-- ...yViaElementArgumentReturnTypeResolver.java | 8 +- .../json/OracleJsonTableFunction.java | 2 +- .../internal/CurrentTimestampGeneration.java | 6 +- .../generator/internal/SourceGeneration.java | 7 +- .../org/hibernate/mapping/BasicValue.java | 68 +++---- .../java/org/hibernate/mapping/Component.java | 20 +- .../metamodel/internal/AttributeFactory.java | 2 +- .../EmbeddableRepresentationStrategyMap.java | 11 +- .../EmbeddableRepresentationStrategyPojo.java | 35 ++-- .../EntityRepresentationStrategyMap.java | 10 +- ...ityRepresentationStrategyPojoStandard.java | 25 ++- .../metamodel/internal/MetadataContext.java | 6 +- .../internal/AbstractEmbeddableMapping.java | 2 +- .../internal/CompoundNaturalIdMapping.java | 6 +- .../internal/EmbeddableMappingTypeImpl.java | 2 +- .../internal/MappingModelCreationHelper.java | 180 +++++++++--------- .../domain/internal/JpaMetamodelImpl.java | 8 +- .../domain/internal/MappingMetamodelImpl.java | 6 +- .../internal/PluralAttributeBuilder.java | 4 +- .../entity/AbstractEntityPersister.java | 4 +- .../hibernate/procedure/internal/Util.java | 3 +- .../hql/internal/SemanticQueryBuilder.java | 4 +- .../internal/ResultMementoBasicStandard.java | 36 ++-- .../query/results/internal/Builders.java | 14 +- .../AbstractFetchBuilderContainer.java | 14 +- .../dynamic/DynamicFetchBuilderLegacy.java | 26 ++- .../dynamic/DynamicFetchBuilderStandard.java | 14 +- .../DynamicResultBuilderAttribute.java | 10 +- .../DynamicResultBuilderBasicConverted.java | 37 ++-- .../DynamicResultBuilderBasicStandard.java | 20 +- .../DynamicResultBuilderEntityCalculated.java | 8 +- .../DynamicResultBuilderEntityStandard.java | 36 ++-- .../DynamicResultBuilderInstantiation.java | 6 +- .../spi/AbstractCommonQueryContract.java | 2 +- .../sqm/internal/SqmCriteriaNodeBuilder.java | 6 +- .../query/sqm/internal/TypecheckUtil.java | 72 ++++--- .../sqm/sql/BaseSqmToSqlAstConverter.java | 19 +- .../tree/expression/SqmUnaryOperation.java | 3 +- .../tree/select/SqmDynamicInstantiation.java | 25 ++- .../select/SqmDynamicInstantiationTarget.java | 2 +- .../internal/InstantiationHelper.java | 9 +- .../sql/results/spi/ListResultsConsumer.java | 16 +- .../org/hibernate/type/BasicTypeRegistry.java | 12 +- .../internal/AttributeConverterBean.java | 5 +- .../converter/internal/ConverterHelper.java | 28 ++- .../java/AbstractArrayJavaType.java | 2 +- .../java/spi/CollectionJavaType.java | 6 +- .../descriptor/java/spi/JavaTypeRegistry.java | 20 +- .../type/descriptor/jdbc/ArrayJdbcType.java | 2 +- .../type/format/jaxb/JaxbXmlFormatMapper.java | 19 +- .../type/internal/BindingTypeHelper.java | 5 +- .../hibernate/type/spi/TypeConfiguration.java | 7 +- .../hibernate/usertype/UserTypeSupport.java | 5 +- .../java/org/hibernate/orm/test/EnumType.java | 15 +- .../mapping/type/format/XmlFormatterTest.java | 9 +- .../vector/internal/HANAVectorJdbcType.java | 2 +- .../internal/MariaDBVectorJdbcType.java | 2 +- .../vector/internal/MySQLVectorJdbcType.java | 2 +- .../internal/PGBinaryVectorJdbcType.java | 2 +- .../internal/PGSparseFloatVectorJdbcType.java | 2 +- .../vector/internal/PGVectorJdbcType.java | 2 +- .../SQLServerCastingVectorJdbcType.java | 2 +- .../validation/MockSessionFactory.java | 4 +- 82 files changed, 635 insertions(+), 642 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/TypeDefinition.java b/hibernate-core/src/main/java/org/hibernate/boot/model/TypeDefinition.java index 339a610ab181..65b2e97e7e63 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/TypeDefinition.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/TypeDefinition.java @@ -7,7 +7,6 @@ import java.io.Serializable; import java.sql.Types; import java.util.Arrays; -import java.util.Collections; import java.util.Map; import java.util.Objects; import java.util.Properties; @@ -15,7 +14,6 @@ import org.hibernate.boot.model.process.internal.UserTypeResolution; import org.hibernate.boot.registry.StandardServiceRegistry; -import org.hibernate.boot.spi.BootstrapContext; import org.hibernate.boot.spi.MetadataBuildingContext; import org.hibernate.boot.spi.MetadataBuildingOptions; import org.hibernate.internal.util.collections.CollectionHelper; @@ -39,6 +37,7 @@ import org.hibernate.type.spi.TypeConfigurationAware; import org.hibernate.usertype.UserType; +import static java.util.Collections.emptyMap; import static org.hibernate.boot.model.process.internal.InferredBasicValueResolver.resolveSqlTypeIndicators; import static org.hibernate.mapping.MappingHelper.injectParameters; @@ -104,7 +103,7 @@ public BasicValue.Resolution resolve( if ( CollectionHelper.isEmpty( localConfigParameters ) ) { // we can use the re-usable resolution... if ( reusableResolution == null ) { - reusableResolution = createResolution( name, Collections.emptyMap(), indicators, context ); + reusableResolution = createResolution( name, emptyMap(), indicators, context ); } return reusableResolution; } @@ -136,9 +135,9 @@ private static BasicValue.Resolution createResolution( Map usageSiteProperties, JdbcTypeIndicators indicators, MetadataBuildingContext context) { - final BootstrapContext bootstrapContext = context.getBootstrapContext(); - final TypeConfiguration typeConfiguration = bootstrapContext.getTypeConfiguration(); - final BeanInstanceProducer instanceProducer = bootstrapContext.getCustomTypeProducer(); + final var bootstrapContext = context.getBootstrapContext(); + final var typeConfiguration = bootstrapContext.getTypeConfiguration(); + final var instanceProducer = bootstrapContext.getCustomTypeProducer(); final boolean isKnownType = Type.class.isAssignableFrom( typeImplementorClass ) || UserType.class.isAssignableFrom( typeImplementorClass ); @@ -165,8 +164,8 @@ private static BasicValue.Resolution createResolution( if ( typeInstance instanceof UserType ) { @SuppressWarnings("unchecked") - final UserType userType = (UserType) typeInstance; - final CustomType customType = new CustomType<>( userType, typeConfiguration ); + final var userType = (UserType) typeInstance; + final var customType = new CustomType<>( userType, typeConfiguration ); return new UserTypeResolution<>( customType, null, combinedTypeParameters ); } @@ -243,13 +242,13 @@ else if ( typeImplementorClass.isInterface() ) { private static BasicValue.Resolution createBasicTypeResolution( BasicType type, - Class typeImplementorClass, + Class typeImplementorClass, JdbcTypeIndicators indicators, TypeConfiguration typeConfiguration) { - final JavaType jtd = typeConfiguration.getJavaTypeRegistry().resolveDescriptor( typeImplementorClass ); - final JdbcType jdbcType = typeConfiguration.getJdbcTypeRegistry().getDescriptor( Types.VARBINARY ); - final BasicType basicType = typeConfiguration.getBasicTypeRegistry().resolve( jtd, jdbcType ); - final BasicType resolved = resolveSqlTypeIndicators( indicators, basicType, jtd ); + final var jtd = typeConfiguration.getJavaTypeRegistry().resolveDescriptor( typeImplementorClass ); + final var jdbcType = typeConfiguration.getJdbcTypeRegistry().getDescriptor( Types.VARBINARY ); + final var basicType = typeConfiguration.getBasicTypeRegistry().resolve( jtd, jdbcType ); + final var resolved = resolveSqlTypeIndicators( indicators, basicType, jtd ); return new BasicValue.Resolution<>() { @Override @@ -304,7 +303,7 @@ private static T instantiateType( : instanceProducer.produceBeanInstance( typeImplementorClass ); } else { - final ManagedBeanRegistry beanRegistry = serviceRegistry.requireService( ManagedBeanRegistry.class ); + final var beanRegistry = serviceRegistry.requireService( ManagedBeanRegistry.class ); final ManagedBean typeBean = name != null ? beanRegistry.getBean( name, typeImplementorClass, instanceProducer ) : beanRegistry.getBean( typeImplementorClass, instanceProducer ); diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/AbstractConverterDescriptor.java b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/AbstractConverterDescriptor.java index ca388fbf86b7..29da7fa7bccc 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/AbstractConverterDescriptor.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/AbstractConverterDescriptor.java @@ -84,7 +84,7 @@ public AutoApplicableConverterDescriptor getAutoApplyDescriptor() { public JpaAttributeConverter createJpaAttributeConverter(JpaAttributeConverterCreationContext context) { return new AttributeConverterBean<>( createManagedBean( context ), - context.getJavaTypeRegistry().getDescriptor( converterClass ), + context.getJavaTypeRegistry().resolveDescriptor( converterClass ), getDomainClass(), getRelationalClass(), context diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterDescriptorImpl.java b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterDescriptorImpl.java index c40a27e4aae3..273c4cb24d37 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterDescriptorImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterDescriptorImpl.java @@ -13,6 +13,7 @@ import org.hibernate.type.descriptor.converter.spi.JpaAttributeConverter; import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; + class ConverterDescriptorImpl implements ConverterDescriptor { private final Class> converterType; private final ResolvedType domainTypeToMatch; @@ -58,9 +59,9 @@ public JpaAttributeConverter createJpaAttributeConverter(JpaAttributeConve final var converterBean = context.getManagedBeanRegistry().getBean( converterType ); return new AttributeConverterBean<>( converterBean, - javaTypeRegistry.getDescriptor( converterBean.getBeanClass() ), - javaTypeRegistry.resolveDescriptor( domainTypeToMatch.getErasedType() ), - javaTypeRegistry.resolveDescriptor( relationalType.getErasedType() ) + javaTypeRegistry.resolveDescriptor( converterBean.getBeanClass() ), + javaTypeRegistry.getDescriptor( domainTypeToMatch.getErasedType() ), + javaTypeRegistry.getDescriptor( relationalType.getErasedType() ) ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterHelper.java b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterHelper.java index 5b3e587d8020..d56ce6bfca52 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterHelper.java @@ -19,7 +19,6 @@ import org.hibernate.models.spi.MemberDetails; import com.fasterxml.classmate.ResolvedType; -import com.fasterxml.classmate.ResolvedTypeWithMembers; import com.fasterxml.classmate.members.ResolvedField; import com.fasterxml.classmate.members.ResolvedMember; import com.fasterxml.classmate.members.ResolvedMethod; @@ -38,15 +37,15 @@ public static ResolvedType resolveAttributeType(MemberDetails memberDetails, Met } public static ResolvedMember resolveMember(MemberDetails memberDetails, MetadataBuildingContext buildingContext) { - final ClassmateContext classmateContext = buildingContext.getBootstrapContext().getClassmateContext(); - final ResolvedType declaringClassType = + final var classmateContext = buildingContext.getBootstrapContext().getClassmateContext(); + final var declaringClassType = classmateContext.getTypeResolver() .resolve( memberDetails.getDeclaringType().toJavaClass() ); - final ResolvedTypeWithMembers declaringClassWithMembers = + final var declaringClassWithMembers = classmateContext.getMemberResolver() .resolve( declaringClassType, null, null ); - final Member member = memberDetails.toJavaMember(); + final var member = memberDetails.toJavaMember(); if ( member instanceof Method ) { for ( ResolvedMethod resolvedMember : declaringClassWithMembers.getMemberMethods() ) { if ( resolvedMember.getName().equals( member.getName() ) ) { @@ -73,8 +72,8 @@ else if ( member instanceof Field ) { public static List resolveConverterClassParamTypes( Class> converterClass, ClassmateContext context) { - final ResolvedType converterType = context.getTypeResolver().resolve( converterClass ); - final List converterParamTypes = converterType.typeParametersFor( AttributeConverter.class ); + final var converterType = context.getTypeResolver().resolve( converterClass ); + final var converterParamTypes = converterType.typeParametersFor( AttributeConverter.class ); if ( converterParamTypes == null ) { throw new AnnotationException( "Could not extract type argument from attribute converter class '" @@ -118,7 +117,7 @@ else if ( erasedCheckType.isArray() ) { } private static boolean checkTypeParametersMatch(ResolvedType converterDefinedType, ResolvedType checkType) { - final List converterTypeParameters = converterDefinedType.getTypeParameters(); + final var converterTypeParameters = converterDefinedType.getTypeParameters(); // if the converter did not define any nested type parameters, // then the checks already done above are enough for a match if ( converterTypeParameters.isEmpty() ) { @@ -129,7 +128,7 @@ private static boolean checkTypeParametersMatch(ResolvedType converterDefinedTyp // so we'd have a converter defined using something like, for example, // List for its domain type, and so we need to check those // nested types as well - final List checkTypeParameters = checkType.getTypeParameters(); + final var checkTypeParameters = checkType.getTypeParameters(); if ( checkTypeParameters.isEmpty() ) { // the domain type did not define nested type params. a List would not auto-match a List() return false; diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationHelper.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationHelper.java index a2f4d4141df5..b6cf53a618be 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationHelper.java @@ -66,15 +66,15 @@ public static JdbcMapping resolveAttributeConverter( valueConverter.getDomainJavaType().getTypeName(), valueConverter.getRelationalJavaType().getTypeName() ), - registry.resolveDescriptor( valueConverter.getRelationalJavaType().getJavaType() ) + registry.resolveDescriptor( valueConverter.getRelationalJavaType().getJavaTypeClass() ) .getRecommendedJdbcType( typeConfiguration.getCurrentBaseSqlTypeIndicators() ), valueConverter ); } - public static BasicType resolveBasicType(Class type, MetadataBuildingContext context) { + public static BasicType resolveBasicType(Class type, MetadataBuildingContext context) { final var typeConfiguration = context.getBootstrapContext().getTypeConfiguration(); - final var jtd = typeConfiguration.getJavaTypeRegistry().findDescriptor( type ); + final JavaType jtd = typeConfiguration.getJavaTypeRegistry().findDescriptor( type ); if ( jtd != null ) { final JdbcType jdbcType = jtd.getRecommendedJdbcType( new JdbcTypeIndicators() { @@ -132,7 +132,9 @@ private static JavaType getJavaType( Class> javaTypeClass, MetadataBuildingContext context, TypeConfiguration typeConfiguration) { - final JavaType registeredJtd = typeConfiguration.getJavaTypeRegistry().findDescriptor( javaTypeClass ); + final JavaType registeredJtd = + typeConfiguration.getJavaTypeRegistry() + .findDescriptor( javaTypeClass ); if ( registeredJtd != null ) { return registeredJtd; } diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/BasicValueBinder.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/BasicValueBinder.java index 6f5b8d665703..e821f34e51d0 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/BasicValueBinder.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/BasicValueBinder.java @@ -403,7 +403,7 @@ private void prepareCollectionId(MemberDetails attribute) { if ( idJavaClass != null ) { return (BasicJavaType) buildingContext.getBootstrapContext().getTypeConfiguration() - .getJavaTypeRegistry().getDescriptor( idJavaClass.idType() ); + .getJavaTypeRegistry().resolveDescriptor( idJavaClass.idType() ); } final var idJavaType = attribute.locateAnnotationUsage( CollectionIdJavaType.class, modelContext ); if ( idJavaType != null ) { @@ -561,7 +561,7 @@ private void prepareMapKey( if ( mapKeyClassAnn != null ) { return (BasicJavaType) typeConfiguration.getJavaTypeRegistry() - .getDescriptor( mapKeyClassAnn.value() ); + .resolveDescriptor( mapKeyClassAnn.value() ); } else { return null; @@ -723,7 +723,7 @@ private void prepareCollectionElement( else { return (BasicJavaType) typeConfiguration.getJavaTypeRegistry() - .getDescriptor( targetClassDetails ); + .resolveDescriptor( targetClassDetails ); } }; } @@ -854,7 +854,7 @@ private void prepareAnyKey(MemberDetails member) { if ( anyKeyJavaClass != null ) { return (BasicJavaType) typeConfiguration.getJavaTypeRegistry() - .getDescriptor( anyKeyJavaClass.value() ); + .resolveDescriptor( anyKeyJavaClass.value() ); } // mainly used in XML interpretation diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java index cbf7b4a81660..11bc77e5d211 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java @@ -23,7 +23,6 @@ import org.hibernate.type.AdjustableBasicType; import org.hibernate.type.BasicPluralType; import org.hibernate.type.BasicType; -import org.hibernate.type.BasicTypeRegistry; import org.hibernate.type.SerializableType; import org.hibernate.type.SqlTypes; import org.hibernate.type.descriptor.java.BasicJavaType; @@ -38,13 +37,11 @@ import org.hibernate.type.descriptor.jdbc.JdbcType; import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators; import org.hibernate.type.descriptor.jdbc.ObjectJdbcType; -import org.hibernate.type.descriptor.jdbc.spi.JdbcTypeRegistry; import org.hibernate.type.internal.ConvertedBasicTypeImpl; import org.hibernate.type.spi.TypeConfiguration; import jakarta.persistence.EnumType; import jakarta.persistence.EnumeratedValue; -import jakarta.persistence.TemporalType; import static org.hibernate.type.SqlTypes.SMALLINT; import static org.hibernate.type.descriptor.java.JavaTypeHelper.isTemporal; @@ -67,11 +64,11 @@ public static BasicValue.Resolution from( String ownerName, String propertyName, MetadataBuildingContext buildingContext) { - final BootstrapContext bootstrapContext = buildingContext.getBootstrapContext(); - final TypeConfiguration typeConfiguration = bootstrapContext.getTypeConfiguration(); - final BasicTypeRegistry basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); + final var bootstrapContext = buildingContext.getBootstrapContext(); + final var typeConfiguration = bootstrapContext.getTypeConfiguration(); + final var basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); - final JavaType reflectedJtd = reflectedJtdResolver.get(); + 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. @@ -97,7 +94,7 @@ else if ( explicitJdbcType != null ) { } else { // we need to infer the JdbcType and use that to build the value-mapping - final JdbcType inferredJdbcType = explicitJavaType.getRecommendedJdbcType( stdIndicators ); + final var inferredJdbcType = explicitJavaType.getRecommendedJdbcType( stdIndicators ); if ( inferredJdbcType instanceof ObjectJdbcType && ( explicitJavaType instanceof SerializableJavaType || explicitJavaType.getJavaType() instanceof Serializable ) ) { @@ -140,7 +137,7 @@ else if ( explicitJdbcType != null ) { else { // see if there is a registered BasicType for this JavaType and, // if so, use it. This mimics the legacy handling. - final BasicType registeredType = + final BasicType registeredType = registeredType( explicitJdbcType, explicitMutabilityPlanAccess, @@ -244,17 +241,18 @@ else if ( column.getLength() != null ) { ); } + final var javaTypeDescriptor = jdbcMapping.getJavaTypeDescriptor(); return new InferredBasicValueResolution<>( jdbcMapping, - jdbcMapping.getJavaTypeDescriptor(), - jdbcMapping.getJavaTypeDescriptor(), + javaTypeDescriptor, + javaTypeDescriptor, jdbcMapping.getJdbcType(), jdbcMapping, - determineMutabilityPlan( explicitMutabilityPlanAccess, jdbcMapping.getJavaTypeDescriptor(), typeConfiguration ) + determineMutabilityPlan( explicitMutabilityPlanAccess, javaTypeDescriptor, typeConfiguration ) ); } - private static BasicType registeredType( + private static BasicType registeredType( JdbcType explicitJdbcType, Function> explicitMutabilityPlanAccess, JdbcTypeIndicators stdIndicators, @@ -262,49 +260,79 @@ private static BasicType registeredType( JavaType reflectedJtd, BootstrapContext bootstrapContext, Dialect dialect) { - final TypeConfiguration typeConfiguration = bootstrapContext.getTypeConfiguration(); - + final var typeConfiguration = bootstrapContext.getTypeConfiguration(); + final var basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); if ( reflectedJtd instanceof BasicPluralJavaType pluralJavaType ) { - final JavaType elementJavaType = pluralJavaType.getElementJavaType(); - final BasicType registeredElementType = registeredElementType( - explicitJdbcType, - explicitMutabilityPlanAccess, - stdIndicators, - bootstrapContext, - elementJavaType - ); - final BasicType registeredType = - registeredElementType == null - ? null - : pluralJavaType.resolveType( - typeConfiguration, - dialect, - resolveSqlTypeIndicators( stdIndicators, registeredElementType, elementJavaType ), - selectable instanceof ColumnTypeInformation information ? information : null, - stdIndicators - ); + final var registeredType = + pluralBasicType( + explicitJdbcType, + explicitMutabilityPlanAccess, + stdIndicators, + selectable, + reflectedJtd, + pluralJavaType, + bootstrapContext, + dialect + ); if ( registeredType instanceof BasicPluralType ) { - typeConfiguration.getBasicTypeRegistry().register( registeredType ); + basicTypeRegistry.register( registeredType ); } return registeredType; } else { - return typeConfiguration.getBasicTypeRegistry().getRegisteredType( reflectedJtd.getJavaType() ); + return basicTypeRegistry.getRegisteredType( reflectedJtd.getJavaTypeClass() ); + } + } + + private static BasicType pluralBasicType( + JdbcType explicitJdbcType, + Function> explicitMutabilityPlanAccess, + JdbcTypeIndicators stdIndicators, + Selectable selectable, + @SuppressWarnings("unused") JavaType reflectedJtd, + BasicPluralJavaType pluralJavaType, + BootstrapContext bootstrapContext, + Dialect dialect) { + final var elementJavaType = pluralJavaType.getElementJavaType(); + final var registeredElementType = registeredElementType( + explicitJdbcType, + explicitMutabilityPlanAccess, + stdIndicators, + bootstrapContext, + elementJavaType + ); + if ( registeredElementType == null ) { + return null; + } + else { + var basicType = + pluralJavaType.resolveType( + bootstrapContext.getTypeConfiguration(), + dialect, + resolveSqlTypeIndicators( stdIndicators, registeredElementType, elementJavaType ), + selectable instanceof ColumnTypeInformation information ? information : null, + stdIndicators + ); + //noinspection unchecked + return (BasicType) basicType; } } - private static BasicType registeredElementType( + private static BasicType registeredElementType( JdbcType explicitJdbcType, Function> explicitMutabilityPlanAccess, JdbcTypeIndicators stdIndicators, BootstrapContext context, - JavaType elementJtd) { + JavaType elementJtd) { if ( elementJtd instanceof EnumJavaType enumJavaType ) { - return (BasicType) fromEnum( enumJavaType, explicitJdbcType, stdIndicators, context ).getJdbcMapping(); + final var resolution = + fromEnum( enumJavaType, explicitJdbcType, stdIndicators, context ); + //noinspection unchecked + return (BasicType) resolution.getJdbcMapping(); } else if ( isTemporal( elementJtd ) ) { - final BasicValue.Resolution resolution = fromTemporal( - (TemporalJavaType) elementJtd, + final var resolution = fromTemporal( + (TemporalJavaType) elementJtd, null, null, explicitMutabilityPlanAccess, @@ -313,7 +341,8 @@ else if ( isTemporal( elementJtd ) ) { return resolution.getLegacyResolvedBasicType(); } else { - return context.getTypeConfiguration().getBasicTypeRegistry().getRegisteredType( elementJtd.getJavaType() ); + return context.getTypeConfiguration().getBasicTypeRegistry() + .getRegisteredType( elementJtd.getJavaTypeClass() ); } } @@ -322,7 +351,7 @@ public static BasicType resolveSqlTypeIndicators( BasicType resolved, JavaType domainJtd) { if ( resolved instanceof AdjustableBasicType indicatorCapable ) { - final BasicType indicatedType = indicatorCapable.resolveIndicatedType( stdIndicators, domainJtd ); + final var indicatedType = indicatorCapable.resolveIndicatedType( stdIndicators, domainJtd ); return indicatedType != null ? indicatedType : resolved; } else { @@ -340,9 +369,9 @@ public static > BasicValue.Resolution fromEnum( validateEnumeratedValue( enumeratedValueField, stdIndicators ); } - final JdbcType jdbcType = + final var jdbcType = enumJdbcType( enumJavaType, explicitJdbcType, stdIndicators, context, enumeratedValueField ); - final BasicType basicType = + final var basicType = enumeratedValueField != null ? createEnumeratedValueJdbcMapping( enumeratedValueField, enumJavaType, jdbcType, context ) : context.getTypeConfiguration().getBasicTypeRegistry().resolve( enumJavaType, jdbcType ); @@ -367,8 +396,8 @@ private static > JdbcType enumJdbcType( return explicitJdbcType; } else if ( enumeratedValueField != null ) { - final JdbcTypeRegistry jdbcTypeRegistry = context.getTypeConfiguration().getJdbcTypeRegistry(); - final Class fieldType = enumeratedValueField.getType(); + final var jdbcTypeRegistry = context.getTypeConfiguration().getJdbcTypeRegistry(); + final var fieldType = enumeratedValueField.getType(); if ( String.class.equals( fieldType ) ) { return jdbcTypeRegistry.getDescriptor( SqlTypes.VARCHAR ); } @@ -393,9 +422,9 @@ private static > BasicType createEnumeratedValueJdbcMapping EnumJavaType enumJavaType, JdbcType jdbcType, BootstrapContext context) { - final JavaType relationalJavaType = + final var relationalJavaType = context.getTypeConfiguration().getJavaTypeRegistry() - .getDescriptor( enumeratedValueField.getType() ); + .resolveDescriptor( enumeratedValueField.getType() ); return new ConvertedBasicTypeImpl<>( ConvertedBasicTypeImpl.EXTERNALIZED_PREFIX + enumJavaType.getTypeName(), "EnumeratedValue conversion for " + enumJavaType.getTypeName(), @@ -454,9 +483,9 @@ public static BasicValue.Resolution fromTemporal( JdbcType explicitJdbcType, Function> explicitMutabilityPlanAccess, JdbcTypeIndicators stdIndicators) { - final TypeConfiguration typeConfiguration = stdIndicators.getTypeConfiguration(); - final BasicTypeRegistry basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); - final TemporalType requestedTemporalPrecision = stdIndicators.getTemporalPrecision(); + final var typeConfiguration = stdIndicators.getTypeConfiguration(); + final var basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); + final var requestedTemporalPrecision = stdIndicators.getTemporalPrecision(); // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Case #1 - explicit JavaType @@ -470,7 +499,7 @@ public static BasicValue.Resolution fromTemporal( } @SuppressWarnings("unchecked") - final TemporalJavaType explicitTemporalJtd = (TemporalJavaType) explicitJavaType; + final var explicitTemporalJtd = (TemporalJavaType) explicitJavaType; if ( requestedTemporalPrecision != null && explicitTemporalJtd.getPrecision() != requestedTemporalPrecision ) { throw new MappingException( "Temporal precision (`jakarta.persistence.TemporalType`) mismatch... requested precision = " + requestedTemporalPrecision + @@ -479,10 +508,11 @@ public static BasicValue.Resolution fromTemporal( ); } - final JdbcType jdbcType = explicitJdbcType != null - ? explicitJdbcType - : explicitTemporalJtd.getRecommendedJdbcType( stdIndicators ); - final BasicType jdbcMapping = basicTypeRegistry.resolve( explicitTemporalJtd, jdbcType ); + final var jdbcType = + explicitJdbcType != null + ? explicitJdbcType + : explicitTemporalJtd.getRecommendedJdbcType( stdIndicators ); + final var jdbcMapping = basicTypeRegistry.resolve( explicitTemporalJtd, jdbcType ); return new InferredBasicValueResolution<>( jdbcMapping, explicitTemporalJtd, @@ -553,7 +583,7 @@ private static MutabilityPlan determineMutabilityPlan( JavaType javaType, TypeConfiguration typeConfiguration) { if ( explicitMutabilityPlanAccess != null ) { - final MutabilityPlan mutabilityPlan = explicitMutabilityPlanAccess.apply( typeConfiguration ); + final var mutabilityPlan = explicitMutabilityPlanAccess.apply( typeConfiguration ); if ( mutabilityPlan != null ) { //noinspection unchecked return (MutabilityPlan) mutabilityPlan; diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/ManagedResourcesImpl.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/ManagedResourcesImpl.java index b455b6fc222d..d6c16f0af629 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/ManagedResourcesImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/ManagedResourcesImpl.java @@ -41,7 +41,7 @@ public class ManagedResourcesImpl implements ManagedResources { private Map> extraQueryImports; public static ManagedResourcesImpl baseline(MetadataSources sources, BootstrapContext bootstrapContext) { - final ManagedResourcesImpl managedResources = new ManagedResourcesImpl(); + final var managedResources = new ManagedResourcesImpl(); bootstrapContext.getAttributeConverters().forEach( managedResources::addAttributeConverterDefinition ); managedResources.annotatedClassReferences.addAll( sources.getAnnotatedClasses() ); managedResources.annotatedClassNames.addAll( sources.getAnnotatedClassNames() ); diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/NamedConverterResolution.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/NamedConverterResolution.java index edf9debd83ca..9884e6441f40 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/NamedConverterResolution.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/NamedConverterResolution.java @@ -14,7 +14,6 @@ import org.hibernate.boot.model.convert.internal.ConverterDescriptors; import org.hibernate.boot.model.convert.spi.ConverterDescriptor; import org.hibernate.boot.model.convert.spi.JpaAttributeConverterCreationContext; -import org.hibernate.boot.spi.BootstrapContext; import org.hibernate.boot.spi.MetadataBuildingContext; import org.hibernate.mapping.BasicValue; import org.hibernate.metamodel.mapping.JdbcMapping; @@ -68,7 +67,7 @@ public static NamedConverterResolution from( assert name.startsWith( ConverterDescriptor.TYPE_NAME_PREFIX ); final String converterClassName = name.substring( ConverterDescriptor.TYPE_NAME_PREFIX.length() ); - final BootstrapContext bootstrapContext = context.getBootstrapContext(); + final var bootstrapContext = context.getBootstrapContext(); final Class> converterClass = bootstrapContext.getClassLoaderService().classForName( converterClassName ); final ConverterDescriptor converterDescriptor = @@ -99,29 +98,32 @@ private static NamedConverterResolution fromInternal( Type resolvedJavaType, JdbcTypeIndicators sqlTypeIndicators, MetadataBuildingContext context) { - final TypeConfiguration typeConfiguration = context.getBootstrapContext().getTypeConfiguration(); + final var typeConfiguration = context.getBootstrapContext().getTypeConfiguration(); //noinspection unchecked - final JavaType explicitJtd = + final var explicitJtd = explicitJtdAccess != null ? (JavaType) explicitJtdAccess.apply( typeConfiguration ) : null; - final JavaType domainJtd = explicitJtd != null - ? explicitJtd - : converter.getDomainJavaType(); + final var domainJtd = + explicitJtd != null + ? explicitJtd + : converter.getDomainJavaType(); - final JdbcType explicitJdbcType = explicitStdAccess != null - ? explicitStdAccess.apply( typeConfiguration ) - : null; + final var explicitJdbcType = + explicitStdAccess != null + ? explicitStdAccess.apply( typeConfiguration ) + : null; - final JavaType relationalJtd = converter.getRelationalJavaType(); + final var relationalJtd = converter.getRelationalJavaType(); - final JdbcType jdbcType = explicitJdbcType != null - ? explicitJdbcType - : relationalJtd.getRecommendedJdbcType( sqlTypeIndicators ); + final var jdbcType = + explicitJdbcType != null + ? explicitJdbcType + : relationalJtd.getRecommendedJdbcType( sqlTypeIndicators ); - final MutabilityPlan mutabilityPlan = determineMutabilityPlan( + final var mutabilityPlan = determineMutabilityPlan( explicitMutabilityPlanAccess, typeConfiguration, converter, @@ -129,7 +131,7 @@ private static NamedConverterResolution fromInternal( ); //noinspection unchecked - final Class primitiveClass = + final var primitiveClass = resolvedJavaType instanceof Class clazz && clazz.isPrimitive() ? (Class) resolvedJavaType : null; @@ -150,7 +152,7 @@ private static MutabilityPlan determineMutabilityPlan( JpaAttributeConverter converter, JavaType domainJtd) { //noinspection unchecked - final MutabilityPlan explicitMutabilityPlan = + final var explicitMutabilityPlan = explicitMutabilityPlanAccess != null ? (MutabilityPlan) explicitMutabilityPlanAccess.apply( typeConfiguration ) : null; diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java index 1a057f02a677..d4250858d261 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java @@ -13,7 +13,6 @@ import org.hibernate.dialect.Dialect; import org.hibernate.mapping.BasicValue; import org.hibernate.metamodel.mapping.JdbcMapping; -import org.hibernate.type.BasicTypeRegistry; import org.hibernate.type.descriptor.converter.spi.BasicValueConverter; import org.hibernate.type.BasicType; import org.hibernate.type.descriptor.java.BasicJavaType; @@ -39,12 +38,12 @@ public static VersionResolution from( // todo (6.0) : add support for Dialect-specific interpretation? - final TypeConfiguration typeConfiguration = context.getBootstrapContext().getTypeConfiguration(); - final java.lang.reflect.Type implicitJavaType = implicitJavaTypeAccess.apply( typeConfiguration ); - final JavaType registered = typeConfiguration.getJavaTypeRegistry().resolveDescriptor( implicitJavaType ); - final BasicJavaType basicJavaType = (BasicJavaType) registered; + final var typeConfiguration = context.getBootstrapContext().getTypeConfiguration(); + final var implicitJavaType = implicitJavaTypeAccess.apply( typeConfiguration ); + final JavaType registered = typeConfiguration.getJavaTypeRegistry().getDescriptor( implicitJavaType ); + final var basicJavaType = (BasicJavaType) registered; - final JdbcType recommendedJdbcType = basicJavaType.getRecommendedJdbcType( + final var recommendedJdbcType = basicJavaType.getRecommendedJdbcType( new JdbcTypeIndicators() { @Override public TypeConfiguration getTypeConfiguration() { @@ -104,9 +103,9 @@ public Dialect getDialect() { } ); - final BasicTypeRegistry basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); - final BasicType basicType = basicTypeRegistry.resolve( basicJavaType, recommendedJdbcType ); - final BasicType legacyType = basicTypeRegistry.getRegisteredType( basicJavaType.getJavaType() ); + final var basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); + final var basicType = basicTypeRegistry.resolve( basicJavaType, recommendedJdbcType ); + final var legacyType = basicTypeRegistry.getRegisteredType( basicJavaType.getJavaTypeClass() ); assert legacyType.getJdbcType().getDefaultSqlTypeCode() == recommendedJdbcType.getDefaultSqlTypeCode(); diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/MetadataBuildingProcess.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/MetadataBuildingProcess.java index f09a02d13273..af8a90295a7a 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/MetadataBuildingProcess.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/MetadataBuildingProcess.java @@ -851,7 +851,7 @@ private static void adaptToPreferredSqlTypeCode( final var javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); final var basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); final BasicType basicType = new NamedBasicTypeImpl<>( - javaTypeRegistry.getDescriptor( javaType ), + javaTypeRegistry.resolveDescriptor( javaType ), jdbcTypeRegistry.getDescriptor( preferredSqlTypeCode ), name ); @@ -866,8 +866,8 @@ private static void adaptTimeTypesToDefaultTimeZoneStorage( JdbcType timestampWithTimeZoneOverride) { final var javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); final var basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); - final BasicType offsetDateTimeType = new NamedBasicTypeImpl<>( - javaTypeRegistry.getDescriptor( OffsetTime.class ), + final BasicType offsetDateTimeType = new NamedBasicTypeImpl<>( + javaTypeRegistry.resolveDescriptor( OffsetTime.class ), timestampWithTimeZoneOverride, "OffsetTime" ); @@ -884,13 +884,13 @@ private static void adaptTimestampTypesToDefaultTimeZoneStorage( JdbcType timestampWithTimeZoneOverride) { final var javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); final var basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); - final BasicType offsetDateTimeType = new NamedBasicTypeImpl<>( - javaTypeRegistry.getDescriptor( OffsetDateTime.class ), + final BasicType offsetDateTimeType = new NamedBasicTypeImpl<>( + javaTypeRegistry.resolveDescriptor( OffsetDateTime.class ), timestampWithTimeZoneOverride, "OffsetDateTime" ); - final BasicType zonedDateTimeType = new NamedBasicTypeImpl<>( - javaTypeRegistry.getDescriptor( ZonedDateTime.class ), + final BasicType zonedDateTimeType = new NamedBasicTypeImpl<>( + javaTypeRegistry.resolveDescriptor( ZonedDateTime.class ), timestampWithTimeZoneOverride, "ZonedDateTime" ); diff --git a/hibernate-core/src/main/java/org/hibernate/boot/query/SqlResultSetMappingDescriptor.java b/hibernate-core/src/main/java/org/hibernate/boot/query/SqlResultSetMappingDescriptor.java index d7effab54989..b9e130ed6766 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/query/SqlResultSetMappingDescriptor.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/query/SqlResultSetMappingDescriptor.java @@ -36,7 +36,6 @@ import org.hibernate.spi.EntityIdentifierNavigablePath; import org.hibernate.spi.NavigablePath; import org.hibernate.sql.results.graph.entity.EntityValuedFetchable; -import org.hibernate.type.descriptor.java.JavaType; import jakarta.persistence.ColumnResult; import jakarta.persistence.ConstructorResult; @@ -213,9 +212,9 @@ public ResultMemento resolve(ResultSetMappingResolutionContext resolutionContext (mapping) -> argumentResultMementos.add( mapping.resolve( resolutionContext ) ) ); - final JavaType targetJtd = + final var targetJtd = resolutionContext.getTypeConfiguration().getJavaTypeRegistry() - .getDescriptor( targetJavaType ); + .resolveDescriptor( targetJavaType ); return new ResultMementoInstantiationStandard( targetJtd, argumentResultMementos ); } diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/CockroachDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/CockroachDialect.java index db81841e09e4..b7b24cbe7fae 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/CockroachDialect.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/CockroachDialect.java @@ -394,7 +394,7 @@ protected void contributeCockroachTypes(TypeContributions typeContributions, Ser ObjectNullAsBinaryTypeJdbcType.INSTANCE, typeContributions.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( Object.class ) + .resolveDescriptor( Object.class ) ) ); diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/DB2Dialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/DB2Dialect.java index 098cd379ea85..0431fd0a604d 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/DB2Dialect.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/DB2Dialect.java @@ -971,7 +971,7 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry ObjectNullResolvingJdbcType.INSTANCE, typeContributions.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( Object.class ) + .resolveDescriptor( Object.class ) ) ); diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/MySQLDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/MySQLDialect.java index 3c64dec330f4..f0a5f40873a0 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/MySQLDialect.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/MySQLDialect.java @@ -725,7 +725,7 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry NullJdbcType.INSTANCE, typeContributions.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( Object.class ) + .resolveDescriptor( Object.class ) ) ); diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/OracleDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/OracleDialect.java index cbafc046020f..6d2692376fcb 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/OracleDialect.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/OracleDialect.java @@ -1063,7 +1063,7 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry NullJdbcType.INSTANCE, typeContributions.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( Object.class ) + .resolveDescriptor( Object.class ) ) ); typeContributions.contributeType( @@ -1071,7 +1071,7 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry ObjectNullAsNullTypeJdbcType.INSTANCE, typeContributions.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( Object.class ) + .resolveDescriptor( Object.class ) ) ); diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/PostgreSQLDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/PostgreSQLDialect.java index ad7b7072c418..9449aa152372 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/PostgreSQLDialect.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/PostgreSQLDialect.java @@ -1504,7 +1504,7 @@ protected void contributePostgreSQLTypes(TypeContributions typeContributions, Se ObjectNullAsBinaryTypeJdbcType.INSTANCE, typeContributions.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( Object.class ) + .resolveDescriptor( Object.class ) ) ); diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/SybaseDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/SybaseDialect.java index d23b2ac11dbc..a7bca1173da3 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/SybaseDialect.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/SybaseDialect.java @@ -260,7 +260,7 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry ObjectNullAsBinaryTypeJdbcType.INSTANCE, typeContributions.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( Object.class ) + .resolveDescriptor( Object.class ) ) ); typeContributions.contributeType( @@ -268,7 +268,7 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry ObjectNullAsBinaryTypeJdbcType.INSTANCE, typeContributions.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( Object.class ) + .resolveDescriptor( Object.class ) ) ); } diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/array/DdlTypeHelper.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/array/DdlTypeHelper.java index e4c0531548a0..1e5be6ab186c 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/function/array/DdlTypeHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/function/array/DdlTypeHelper.java @@ -4,7 +4,6 @@ */ package org.hibernate.dialect.function.array; -import java.lang.reflect.Array; import java.lang.reflect.Type; import java.util.List; @@ -27,10 +26,11 @@ public class DdlTypeHelper { @SuppressWarnings("unchecked") @AllowReflection public static BasicType resolveArrayType(DomainType elementType, TypeConfiguration typeConfiguration) { - @SuppressWarnings("unchecked") final BasicPluralJavaType arrayJavaType = (BasicPluralJavaType) typeConfiguration.getJavaTypeRegistry() - .getDescriptor( - Array.newInstance( elementType.getJavaType(), 0 ).getClass() - ); + @SuppressWarnings("unchecked") + final var arrayJavaType = + (BasicPluralJavaType) + typeConfiguration.getJavaTypeRegistry() + .resolveArrayDescriptor( elementType.getJavaType() ); final Dialect dialect = typeConfiguration.getCurrentBaseSqlTypeIndicators().getDialect(); return arrayJavaType.resolveType( typeConfiguration, @@ -43,12 +43,15 @@ public static BasicType resolveArrayType(DomainType elementType, TypeConfi @SuppressWarnings("unchecked") public static BasicType resolveListType(DomainType elementType, TypeConfiguration typeConfiguration) { - @SuppressWarnings("unchecked") final BasicPluralJavaType arrayJavaType = (BasicPluralJavaType) typeConfiguration.getJavaTypeRegistry() - .getDescriptor( List.class ) - .createJavaType( - new ParameterizedTypeImpl( List.class, new Type[]{ elementType.getJavaType() }, null ), - typeConfiguration - ); + @SuppressWarnings("unchecked") + final BasicPluralJavaType arrayJavaType = + (BasicPluralJavaType) + typeConfiguration.getJavaTypeRegistry() + .getDescriptor( List.class ) + .createJavaType( + new ParameterizedTypeImpl( List.class, new Type[]{ elementType.getJavaType() }, null ), + typeConfiguration + ); final Dialect dialect = typeConfiguration.getCurrentBaseSqlTypeIndicators().getDialect(); return arrayJavaType.resolveType( typeConfiguration, diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/array/JsonArrayViaElementArgumentReturnTypeResolver.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/array/JsonArrayViaElementArgumentReturnTypeResolver.java index da1b97d26276..ce7ed772650b 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/function/array/JsonArrayViaElementArgumentReturnTypeResolver.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/function/array/JsonArrayViaElementArgumentReturnTypeResolver.java @@ -4,7 +4,6 @@ */ package org.hibernate.dialect.function.array; -import java.lang.reflect.Array; import java.util.List; import java.util.function.Supplier; @@ -81,10 +80,11 @@ public BasicValuedMapping resolveFunctionReturnType( @AllowReflection public static BasicType resolveJsonArrayType(DomainType elementType, TypeConfiguration typeConfiguration) { - final Class arrayClass = Array.newInstance( elementType.getJavaType(), 0 ).getClass(); @SuppressWarnings("unchecked") - final BasicPluralJavaType arrayJavaType = - (BasicPluralJavaType) typeConfiguration.getJavaTypeRegistry().getDescriptor( arrayClass ); + final var arrayJavaType = + (BasicPluralJavaType) + typeConfiguration.getJavaTypeRegistry() + .resolveArrayDescriptor( elementType.getJavaType() ); final JdbcTypeIndicators currentBaseSqlTypeIndicators = typeConfiguration.getCurrentBaseSqlTypeIndicators(); return arrayJavaType.resolveType( typeConfiguration, diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/json/OracleJsonTableFunction.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/json/OracleJsonTableFunction.java index 2b795a7a8288..6ab41692351a 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/function/json/OracleJsonTableFunction.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/function/json/OracleJsonTableFunction.java @@ -101,7 +101,7 @@ protected void addSelectableMappings(List selectableMappings, selectableMappings, definition.name(), typeConfiguration.getBasicTypeRegistry().resolve( - typeConfiguration.getJavaTypeRegistry().getDescriptor( String.class ), + typeConfiguration.getJavaTypeRegistry().resolveDescriptor( String.class ), JsonAsStringJdbcType.CLOB_INSTANCE ), converter diff --git a/hibernate-core/src/main/java/org/hibernate/generator/internal/CurrentTimestampGeneration.java b/hibernate-core/src/main/java/org/hibernate/generator/internal/CurrentTimestampGeneration.java index 4702f1329cbe..12f6fea67e67 100644 --- a/hibernate-core/src/main/java/org/hibernate/generator/internal/CurrentTimestampGeneration.java +++ b/hibernate-core/src/main/java/org/hibernate/generator/internal/CurrentTimestampGeneration.java @@ -81,7 +81,7 @@ public class CurrentTimestampGeneration implements BeforeExecutionGenerator, OnE public static final String CLOCK_SETTING_NAME = "hibernate.testing.clock"; private final EnumSet eventTypes; - private final JavaType propertyType; + private final JavaType propertyType; private final GeneratorDelegate delegate; private static final ConcurrentHashMap GENERATOR_DELEGATES = new ConcurrentHashMap<>(); @@ -157,9 +157,9 @@ public static T getClock(SessionFactory sessionFactory) { return (T) sessionFactory.getProperties().get( CLOCK_SETTING_NAME ); } - private static JavaType getPropertyType(GeneratorCreationContext context) { + private static JavaType getPropertyType(GeneratorCreationContext context) { return context.getDatabase().getTypeConfiguration().getJavaTypeRegistry() - .getDescriptor( context.getProperty().getType().getReturnedClass() ); + .resolveDescriptor( context.getProperty().getType().getReturnedClass() ); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/generator/internal/SourceGeneration.java b/hibernate-core/src/main/java/org/hibernate/generator/internal/SourceGeneration.java index dd7a014c3f08..333735e46e1f 100644 --- a/hibernate-core/src/main/java/org/hibernate/generator/internal/SourceGeneration.java +++ b/hibernate-core/src/main/java/org/hibernate/generator/internal/SourceGeneration.java @@ -20,6 +20,7 @@ import java.util.EnumSet; import static org.hibernate.generator.internal.CurrentTimestampGeneration.getCurrentTimestamp; +import static org.hibernate.generator.internal.CurrentTimestampGeneration.getGeneratorDelegate; /** * Value generation strategy using the query {@link Dialect#getCurrentTimestampSelectString()}. @@ -49,8 +50,10 @@ public SourceGeneration(Source annotation, Member member, GeneratorCreationConte } public SourceGeneration(SourceType sourceType, Class propertyType, GeneratorCreationContext context) { - this.propertyType = context.getDatabase().getTypeConfiguration().getJavaTypeRegistry().getDescriptor( propertyType ); - this.valueGenerator = CurrentTimestampGeneration.getGeneratorDelegate( sourceType, propertyType, context ); + this.propertyType = + context.getDatabase().getTypeConfiguration().getJavaTypeRegistry() + .resolveDescriptor( propertyType ); + this.valueGenerator = getGeneratorDelegate( sourceType, propertyType, context ); } /** diff --git a/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java b/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java index e5843b7407b6..da083ca34b2d 100644 --- a/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java +++ b/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java @@ -19,7 +19,6 @@ import org.hibernate.annotations.TimeZoneStorageType; import org.hibernate.boot.model.convert.internal.ConverterDescriptors; import org.hibernate.boot.spi.BootstrapContext; -import org.hibernate.boot.spi.ClassmateContext; import org.hibernate.boot.model.TypeDefinition; import org.hibernate.boot.model.convert.internal.AutoApplicableConverterDescriptorBypassedImpl; import org.hibernate.boot.model.convert.spi.AutoApplicableConverterDescriptor; @@ -40,7 +39,6 @@ import org.hibernate.metamodel.mapping.JdbcMapping; import org.hibernate.metamodel.mapping.SelectablePath; import org.hibernate.resource.beans.internal.FallbackBeanInstanceProducer; -import org.hibernate.resource.beans.spi.BeanInstanceProducer; import org.hibernate.resource.beans.spi.ManagedBean; import org.hibernate.resource.beans.spi.ManagedBeanRegistry; import org.hibernate.tool.schema.extract.spi.ColumnTypeInformation; @@ -57,7 +55,6 @@ import org.hibernate.type.descriptor.java.BasicPluralJavaType; import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.java.MutabilityPlan; -import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; import org.hibernate.type.descriptor.java.spi.JsonJavaType; import org.hibernate.type.descriptor.java.spi.RegistryHelper; import org.hibernate.type.descriptor.java.spi.XmlJavaType; @@ -319,8 +316,9 @@ public void addFormula(Formula formula) { @Override public Type getType() throws MappingException { resolve(); - assert getResolution() != null; - return getResolution().getLegacyResolvedBasicType(); + final var resolution = getResolution(); + assert resolution != null; + return resolution.getLegacyResolvedBasicType(); } public Resolution getResolution() { @@ -392,8 +390,9 @@ private void resolveColumn(Column column, Dialect dialect) { // } if ( dialect.supportsColumnCheck() ) { - final String checkCondition = resolution.getLegacyResolvedBasicType() - .getCheckCondition( column.getQuotedName( dialect ), dialect ); + final String checkCondition = + resolution.getLegacyResolvedBasicType() + .getCheckCondition( column.getQuotedName( dialect ), dialect ); if ( checkCondition != null ) { column.addCheckConstraint( new CheckConstraint( checkCondition ) ); } @@ -415,7 +414,7 @@ public SelectablePath createSelectablePath(String selectableName) { } protected Resolution buildResolution() { - final Properties typeParameters = getTypeParameters(); + final var typeParameters = getTypeParameters(); if ( typeParameters != null && parseBoolean( typeParameters.getProperty(DynamicParameterizedType.IS_DYNAMIC) ) && typeParameters.get(DynamicParameterizedType.PARAMETER_TYPE) == null ) { @@ -443,8 +442,8 @@ else if ( isVersion() ) { } else { // determine JavaType if we can - final JavaType javaType = determineJavaType(); - final ConverterDescriptor converterDescriptor = getConverterDescriptor( javaType ); + final var javaType = determineJavaType(); + final var converterDescriptor = getConverterDescriptor( javaType ); return converterDescriptor != null ? converterResolution( javaType, converterDescriptor ) : resolution( getExplicitJavaType(), javaType ); @@ -456,13 +455,13 @@ private BasicJavaType getExplicitJavaType() { } private ConverterDescriptor getConverterDescriptor(JavaType javaType) { - final ConverterDescriptor converterDescriptor = getAttributeConverterDescriptor(); + final var converterDescriptor = getAttributeConverterDescriptor(); if ( isSoftDelete() && getSoftDeleteStrategy() != SoftDeleteType.TIMESTAMP ) { assert converterDescriptor != null; @SuppressWarnings("unchecked") - final ConverterDescriptor booleanConverterDescriptor = + final var booleanConverterDescriptor = (ConverterDescriptor) converterDescriptor; - final ConverterDescriptor softDeleteConverterDescriptor = + final var softDeleteConverterDescriptor = getSoftDeleteConverterDescriptor( booleanConverterDescriptor, javaType ); return getSoftDeleteStrategy() == SoftDeleteType.ACTIVE ? new ReversedConverterDescriptor<>( softDeleteConverterDescriptor ) @@ -478,8 +477,8 @@ private ConverterDescriptor getSoftDeleteConverterDescriptor( final boolean conversionWasUnspecified = SoftDelete.UnspecifiedConversion.class.equals( attributeConverterDescriptor.getAttributeConverterClass() ); if ( conversionWasUnspecified ) { - final JdbcType jdbcType = BooleanJdbcType.INSTANCE.resolveIndicatedType( this, javaType ); - final ClassmateContext classmateContext = getBuildingContext().getBootstrapContext().getClassmateContext(); + final var jdbcType = BooleanJdbcType.INSTANCE.resolveIndicatedType( this, javaType ); + final var classmateContext = getBuildingContext().getBootstrapContext().getClassmateContext(); if ( jdbcType.isNumber() ) { return ConverterDescriptors.of( NumericBooleanConverter.INSTANCE, classmateContext ); } @@ -619,7 +618,7 @@ private Resolution resolution(BasicJavaType explicitJavaType, JavaType final JavaType basicJavaType; final JdbcType jdbcType; if ( explicitJdbcTypeAccess != null ) { - final TypeConfiguration typeConfiguration = getTypeConfiguration(); + final var typeConfiguration = getTypeConfiguration(); jdbcType = explicitJdbcTypeAccess.apply( typeConfiguration ); basicJavaType = javaType == null && jdbcType != null ? jdbcType.getJdbcRecommendedJavaTypeMapping( null, null, typeConfiguration ) @@ -635,8 +634,8 @@ private Resolution resolution(BasicJavaType explicitJavaType, JavaType if ( basicJavaType instanceof BasicJavaType castType && ( !basicJavaType.getJavaTypeClass().isEnum() || enumerationStyle == null ) ) { - final MetadataBuildingContext context = getBuildingContext(); - final TypeDefinition autoAppliedTypeDef = context.getTypeDefinitionRegistry().resolveAutoApplied( castType ); + final var context = getBuildingContext(); + final var autoAppliedTypeDef = context.getTypeDefinitionRegistry().resolveAutoApplied( castType ); if ( autoAppliedTypeDef != null ) { LOG.trace( "BasicValue resolution matched auto-applied type definition" ); return autoAppliedTypeDef.resolve( getTypeParameters(), null, context, this ); @@ -664,7 +663,7 @@ public ManagedBeanRegistry getManagedBeanRegistry() { } private Resolution converterResolution(JavaType javaType, ConverterDescriptor attributeConverterDescriptor) { - final NamedConverterResolution converterResolution = NamedConverterResolution.from( + final var converterResolution = NamedConverterResolution.from( attributeConverterDescriptor, explicitJavaTypeAccess, explicitJdbcTypeAccess, @@ -717,7 +716,7 @@ private JavaType determineJavaType() { // } if ( javaType == null ) { - final JavaType reflectedJtd = determineReflectedJavaType(); + final var reflectedJtd = determineReflectedJavaType(); if ( reflectedJtd != null ) { return reflectedJtd; } @@ -727,8 +726,8 @@ private JavaType determineJavaType() { } private JavaType determineReflectedJavaType() { - final TypeConfiguration typeConfiguration = getTypeConfiguration(); - final java.lang.reflect.Type impliedJavaType = impliedJavaType( typeConfiguration ); + final var typeConfiguration = getTypeConfiguration(); + final var impliedJavaType = impliedJavaType( typeConfiguration ); if ( impliedJavaType == null ) { return null; } @@ -762,7 +761,7 @@ private JavaType javaType(TypeConfiguration typeConfiguration, java.lang.refl private JavaType specialJavaType( TypeConfiguration typeConfiguration, java.lang.reflect.Type impliedJavaType) { - final JavaTypeRegistry javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); + final var javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); if ( jdbcTypeCode != null ) { // Construct special JavaType instances for JSON/XML types which can report recommended JDBC types // and implement toString/fromString as well as copying based on FormatMapper operations @@ -783,12 +782,12 @@ private JavaType specialJavaType( return xmlJavaType; } } - return javaTypeRegistry.resolveDescriptor( impliedJavaType ); + return javaTypeRegistry.getDescriptor( impliedJavaType ); } private MutabilityPlan mutabilityPlan( TypeConfiguration typeConfiguration, java.lang.reflect.Type impliedJavaType) { - final MutabilityPlan explicitMutabilityPlan = getExplicitMutabilityPlan(); + final var explicitMutabilityPlan = getExplicitMutabilityPlan(); return explicitMutabilityPlan != null ? explicitMutabilityPlan : RegistryHelper.INSTANCE.determineMutabilityPlan( impliedJavaType, typeConfiguration ); @@ -810,10 +809,10 @@ private static Resolution interpretExplicitlyNamedType( JdbcTypeIndicators stdIndicators, MetadataBuildingContext context) { - final BootstrapContext bootstrapContext = context.getBootstrapContext(); + final var bootstrapContext = context.getBootstrapContext(); - final ManagedBeanRegistry managedBeanRegistry = bootstrapContext.getManagedBeanRegistry(); - final TypeConfiguration typeConfiguration = bootstrapContext.getTypeConfiguration(); + final var managedBeanRegistry = bootstrapContext.getManagedBeanRegistry(); + final var typeConfiguration = bootstrapContext.getTypeConfiguration(); final JpaAttributeConverterCreationContext converterCreationContext = new JpaAttributeConverterCreationContext() { @Override @@ -860,7 +859,8 @@ public TypeConfiguration getTypeConfiguration() { } // see if it is a named basic type - final BasicType basicTypeByName = typeConfiguration.getBasicTypeRegistry().getRegisteredType( name ); + final BasicType basicTypeByName = + typeConfiguration.getBasicTypeRegistry().getRegisteredType( name ); if ( basicTypeByName != null ) { return getNamedBasicTypeResolution( explicitMutabilityPlanAccess, @@ -872,7 +872,7 @@ public TypeConfiguration getTypeConfiguration() { } // see if it is a named TypeDefinition - final TypeDefinition typeDefinition = context.getTypeDefinitionRegistry().resolve( name ); + final var typeDefinition = context.getTypeDefinitionRegistry().resolve( name ); if ( typeDefinition != null ) { final Resolution resolution = typeDefinition.resolve( localTypeParams, @@ -890,7 +890,7 @@ public TypeConfiguration getTypeConfiguration() { // if there are no local config params, register an implicit TypeDefinition for this custom type // later uses may find it and reuse its cacheable reference if ( isEmpty( localTypeParams ) ) { - final TypeDefinition implicitDefinition = + final var implicitDefinition = new TypeDefinition( name, typeNamedClass, null, null ); context.getTypeDefinitionRegistry().register( implicitDefinition ); return implicitDefinition.resolve( @@ -1064,7 +1064,7 @@ public void setExplicitCustomType(Class> explicitCustomTyp } private Properties getCustomTypeProperties() { - final Properties properties = new Properties(); + final var properties = new Properties(); if ( isNotEmpty( getTypeParameters() ) ) { properties.putAll( getTypeParameters() ); } @@ -1075,7 +1075,7 @@ private Properties getCustomTypeProperties() { } private UserType getConfiguredUserTypeBean(Class> explicitCustomType, Properties properties) { - final UserType typeInstance = + final var typeInstance = getBuildingContext().getBuildingOptions().isAllowExtensionsInCdi() ? getUserTypeBean( explicitCustomType, properties ).getBeanInstance() : FallbackBeanInstanceProducer.INSTANCE.produceBeanInstance( explicitCustomType ); @@ -1100,7 +1100,7 @@ private UserType getConfiguredUserTypeBean(Class> expli } private ManagedBean getUserTypeBean(Class explicitCustomType, Properties properties) { - final BeanInstanceProducer producer = getBuildingContext().getBootstrapContext().getCustomTypeProducer(); + final var producer = getBuildingContext().getBootstrapContext().getCustomTypeProducer(); if ( isNotEmpty( properties ) ) { final String name = explicitCustomType.getName() + COUNTER++; return getManagedBeanRegistry().getBean( name, explicitCustomType, producer ); diff --git a/hibernate-core/src/main/java/org/hibernate/mapping/Component.java b/hibernate-core/src/main/java/org/hibernate/mapping/Component.java index a20d49fef36e..0d169e1d8767 100644 --- a/hibernate-core/src/main/java/org/hibernate/mapping/Component.java +++ b/hibernate-core/src/main/java/org/hibernate/mapping/Component.java @@ -34,7 +34,6 @@ import org.hibernate.internal.util.ReflectHelper; import org.hibernate.internal.util.collections.ArrayHelper; import org.hibernate.internal.util.collections.CollectionHelper; -import org.hibernate.metamodel.mapping.DiscriminatorConverter; import org.hibernate.metamodel.mapping.DiscriminatorType; import org.hibernate.metamodel.mapping.EmbeddableDiscriminatorConverter; import org.hibernate.metamodel.mapping.internal.DiscriminatorTypeImpl; @@ -43,13 +42,10 @@ import org.hibernate.models.spi.ClassDetails; import org.hibernate.property.access.spi.Setter; import org.hibernate.resource.beans.internal.FallbackBeanInstanceProducer; -import org.hibernate.type.BasicType; import org.hibernate.type.ComponentType; import org.hibernate.type.CompositeType; import org.hibernate.type.EmbeddedComponentType; import org.hibernate.type.UserComponentType; -import org.hibernate.type.descriptor.java.JavaType; -import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; import org.hibernate.type.MappingContext; import org.hibernate.usertype.CompositeUserType; @@ -603,19 +599,19 @@ public void setDiscriminator(Value discriminator) { } public DiscriminatorType getDiscriminatorType() { - DiscriminatorType type = discriminatorType; + final var type = discriminatorType; if ( type == null ) { - type = discriminatorType = buildDiscriminatorType(); + return discriminatorType = buildDiscriminatorType(); } return type; } private DiscriminatorType buildDiscriminatorType() { return getBuildingContext().getMetadataCollector().resolveEmbeddableDiscriminatorType( getComponentClass(), () -> { - final JavaTypeRegistry javaTypeRegistry = getTypeConfiguration().getJavaTypeRegistry(); - final JavaType domainJavaType = javaTypeRegistry.resolveDescriptor( Class.class ); - final BasicType discriminatorType = DiscriminatorHelper.getDiscriminatorType( this ); - final DiscriminatorConverter converter = EmbeddableDiscriminatorConverter.fromValueMappings( + final var javaTypeRegistry = getTypeConfiguration().getJavaTypeRegistry(); + final var domainJavaType = javaTypeRegistry.resolveDescriptor( Class.class ); + final var discriminatorType = DiscriminatorHelper.getDiscriminatorType( this ); + final var converter = EmbeddableDiscriminatorConverter.fromValueMappings( qualify( getComponentClassName(), DISCRIMINATOR_ROLE_NAME ), domainJavaType, discriminatorType, @@ -659,12 +655,12 @@ public Generator createGenerator(Dialect dialect, RootClass rootClass, Property } private Generator buildIdentifierGenerator(Dialect dialect, RootClass rootClass, GeneratorSettings defaults) { - final CompositeNestedGeneratedValueGenerator generator = + final var generator = new CompositeNestedGeneratedValueGenerator( new StandardGenerationContextLocator( rootClass.getEntityName() ), getType() ); - final List properties = getProperties(); + final var properties = getProperties(); for ( int i = 0; i < properties.size(); i++ ) { final Property property = properties.get( i ); if ( property.getValue().isSimpleValue() ) { diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java index 8bc5b43b4e6e..862a4d6fc7ed 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java @@ -279,7 +279,7 @@ private static EmbeddableDomainType classEmbeddableType(MetadataContext conte private static EmbeddableTypeImpl dynamicEmbeddableType(MetadataContext context, Component component) { final var embeddableType = new EmbeddableTypeImpl<>( - context.getJavaTypeRegistry().getDescriptor( java.util.Map.class ), + context.getJavaTypeRegistry().resolveDescriptor( java.util.Map.class ), null, null, true, diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyMap.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyMap.java index 6ddc601b6b00..7ef12d899936 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyMap.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyMap.java @@ -31,10 +31,13 @@ public EmbeddableRepresentationStrategyMap( Supplier runtimeDescriptorAccess, EmbeddableInstantiator customInstantiator, RuntimeModelCreationContext creationContext) { - this.mapJavaType = creationContext.getTypeConfiguration().getJavaTypeRegistry().getDescriptor( Map.class ); - this.instantiator = customInstantiator != null - ? customInstantiator - : new EmbeddableInstantiatorDynamicMap( bootDescriptor, runtimeDescriptorAccess ); + mapJavaType = + creationContext.getTypeConfiguration().getJavaTypeRegistry() + .getDescriptor( Map.class ); + instantiator = + customInstantiator == null + ? new EmbeddableInstantiatorDynamicMap( bootDescriptor, runtimeDescriptorAccess ) + : customInstantiator; } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyPojo.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyPojo.java index efe75d482a05..b9c2b2de4e90 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyPojo.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyPojo.java @@ -26,7 +26,6 @@ import org.hibernate.metamodel.spi.RuntimeModelCreationContext; import org.hibernate.property.access.spi.PropertyAccess; import org.hibernate.type.descriptor.java.JavaType; -import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; import org.hibernate.type.internal.CompositeUserTypeJavaTypeWrapper; import org.hibernate.usertype.CompositeUserType; @@ -54,20 +53,20 @@ public EmbeddableRepresentationStrategyPojo( EmbeddableInstantiator customInstantiator, CompositeUserType compositeUserType, RuntimeModelCreationContext creationContext) { - this.embeddableJavaType = resolveEmbeddableJavaType( bootDescriptor, compositeUserType, creationContext ); + embeddableJavaType = resolveEmbeddableJavaType( bootDescriptor, compositeUserType, creationContext ); final int propertySpan = bootDescriptor.getPropertySpan(); - this.propertyAccesses = new PropertyAccess[propertySpan]; - this.attributeNameToPositionMap = new HashMap<>( propertySpan ); + propertyAccesses = new PropertyAccess[propertySpan]; + attributeNameToPositionMap = new HashMap<>( propertySpan ); // We need access to the Class objects, used only during initialization - final Map> subclassesByName = getSubclassesByName( bootDescriptor, creationContext ); + final var subclassesByName = getSubclassesByName( bootDescriptor, creationContext ); boolean foundCustomAccessor = false; for ( int i = 0; i < bootDescriptor.getProperties().size(); i++ ) { final Property property = bootDescriptor.getProperty( i ); final Class embeddableClass; if ( subclassesByName != null ) { - final Class subclass = subclassesByName.get( bootDescriptor.getPropertyDeclaringClass( property ) ); + final var subclass = subclassesByName.get( bootDescriptor.getPropertyDeclaringClass( property ) ); embeddableClass = subclass != null ? subclass : getEmbeddableJavaType().getJavaTypeClass(); } else { @@ -82,8 +81,8 @@ public EmbeddableRepresentationStrategyPojo( } boolean hasCustomAccessors = foundCustomAccessor; - this.strategySelector = creationContext.getServiceRegistry().getService( StrategySelector.class ); - this.reflectionOptimizer = buildReflectionOptimizer( + strategySelector = creationContext.getServiceRegistry().getService( StrategySelector.class ); + reflectionOptimizer = buildReflectionOptimizer( bootDescriptor, hasCustomAccessors, propertyAccesses, @@ -92,11 +91,11 @@ public EmbeddableRepresentationStrategyPojo( if ( bootDescriptor.isPolymorphic() ) { final int size = bootDescriptor.getDiscriminatorValues().size(); - this.instantiatorsByDiscriminator = new HashMap<>( size ); - this.instantiatorsByClass = new HashMap<>( size ); - for ( Map.Entry discriminator : bootDescriptor.getDiscriminatorValues().entrySet() ) { + instantiatorsByDiscriminator = new HashMap<>( size ); + instantiatorsByClass = new HashMap<>( size ); + for ( var discriminator : bootDescriptor.getDiscriminatorValues().entrySet() ) { final String className = discriminator.getValue(); - final EmbeddableInstantiator instantiator = determineInstantiator( + final var instantiator = determineInstantiator( bootDescriptor, castNonNull( subclassesByName ).get( className ), reflectionOptimizer, @@ -106,10 +105,10 @@ public EmbeddableRepresentationStrategyPojo( instantiatorsByDiscriminator.put( discriminator.getKey(), instantiator ); instantiatorsByClass.put( className, instantiator ); } - this.instantiator = null; + instantiator = null; } else { - this.instantiator = customInstantiator != null ? + instantiator = customInstantiator != null ? customInstantiator : determineInstantiator( bootDescriptor, @@ -118,8 +117,8 @@ public EmbeddableRepresentationStrategyPojo( runtimeDescriptorAccess, creationContext ); - this.instantiatorsByDiscriminator = null; - this.instantiatorsByClass = null; + instantiatorsByDiscriminator = null; + instantiatorsByClass = null; } } @@ -127,9 +126,9 @@ private static JavaType resolveEmbeddableJavaType( Component bootDescriptor, CompositeUserType compositeUserType, RuntimeModelCreationContext creationContext) { - final JavaTypeRegistry javaTypeRegistry = creationContext.getTypeConfiguration().getJavaTypeRegistry(); + final var javaTypeRegistry = creationContext.getTypeConfiguration().getJavaTypeRegistry(); if ( compositeUserType == null ) { - return javaTypeRegistry.resolveDescriptor( bootDescriptor.getComponentClass() ); + return javaTypeRegistry.getDescriptor( bootDescriptor.getComponentClass() ); } else { return javaTypeRegistry.resolveDescriptor( diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityRepresentationStrategyMap.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityRepresentationStrategyMap.java index 657e0d39cda6..fc853f853e97 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityRepresentationStrategyMap.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityRepresentationStrategyMap.java @@ -39,12 +39,12 @@ public class EntityRepresentationStrategyMap implements EntityRepresentationStra public EntityRepresentationStrategyMap( PersistentClass bootType, RuntimeModelCreationContext creationContext) { - this.mapJavaType = creationContext.getTypeConfiguration() - .getJavaTypeRegistry() - .getDescriptor( Map.class ); + mapJavaType = + creationContext.getTypeConfiguration().getJavaTypeRegistry() + .getDescriptor( Map.class ); - this.proxyFactory = createProxyFactory( bootType ); - this.instantiator = new EntityInstantiatorDynamicMap( bootType ); + proxyFactory = createProxyFactory( bootType ); + instantiator = new EntityInstantiatorDynamicMap( bootType ); createProxyFactory( bootType ); } diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityRepresentationStrategyPojoStandard.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityRepresentationStrategyPojoStandard.java index 4742d5f04e65..4c758e1fff4e 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityRepresentationStrategyPojoStandard.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityRepresentationStrategyPojoStandard.java @@ -21,7 +21,6 @@ import org.hibernate.mapping.Component; import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Property; -import org.hibernate.mapping.Subclass; import org.hibernate.metamodel.RepresentationMode; import org.hibernate.metamodel.spi.EntityInstantiator; import org.hibernate.metamodel.spi.EntityRepresentationStrategy; @@ -69,15 +68,15 @@ public EntityRepresentationStrategyPojoStandard( RuntimeModelCreationContext creationContext) { final var registry = creationContext.getTypeConfiguration().getJavaTypeRegistry(); - final Class mappedJavaType = bootDescriptor.getMappedClass(); + final var mappedJavaType = bootDescriptor.getMappedClass(); mappedJtd = registry.resolveEntityTypeDescriptor( mappedJavaType ); - final Class proxyJavaType = bootDescriptor.getProxyInterface(); - proxyJtd = proxyJavaType != null ? registry.getDescriptor( proxyJavaType ) : null; + final var proxyJavaType = bootDescriptor.getProxyInterface(); + proxyJtd = proxyJavaType != null ? registry.resolveDescriptor( proxyJavaType ) : null; isBytecodeEnhanced = isPersistentAttributeInterceptableType( mappedJavaType ); - final Property identifierProperty = bootDescriptor.getIdentifierProperty(); + final var identifierProperty = bootDescriptor.getIdentifierProperty(); if ( identifierProperty == null ) { identifierPropertyName = null; identifierPropertyAccess = null; @@ -182,12 +181,12 @@ private ProxyFactory createProxyFactory( BytecodeProvider bytecodeProvider, RuntimeModelCreationContext creationContext) { - final Class mappedClass = mappedJtd.getJavaTypeClass(); - final Class proxyInterface = proxyJtd == null ? null : proxyJtd.getJavaTypeClass(); + final var mappedClass = mappedJtd.getJavaTypeClass(); + final var proxyInterface = proxyJtd == null ? null : proxyJtd.getJavaTypeClass(); - final Set> proxyInterfaces = proxyInterfaces( bootDescriptor, proxyInterface, mappedClass ); + final var proxyInterfaces = proxyInterfaces( bootDescriptor, proxyInterface, mappedClass ); - final Class clazz = bootDescriptor.getMappedClass(); + final var clazz = bootDescriptor.getMappedClass(); final Method idGetterMethod; final Method idSetterMethod; try { @@ -213,10 +212,10 @@ private ProxyFactory createProxyFactory( return null; } - final Method proxyGetIdentifierMethod = + final var proxyGetIdentifierMethod = idGetterMethod == null || proxyInterface == null ? null : getMethod( proxyInterface, idGetterMethod ); - final Method proxySetIdentifierMethod = + final var proxySetIdentifierMethod = idSetterMethod == null || proxyInterface == null ? null : getMethod( proxyInterface, idSetterMethod ); @@ -254,7 +253,7 @@ private static Set> proxyInterfaces( proxyInterfaces.add( mappedClass ); } - for ( Subclass subclass : bootDescriptor.getSubclasses() ) { + for ( var subclass : bootDescriptor.getSubclasses() ) { final Class subclassProxy = subclass.getProxyInterface(); final Class subclassClass = subclass.getMappedClass(); if ( subclassProxy != null && !subclassClass.equals( subclassProxy ) ) { @@ -307,7 +306,7 @@ private ReflectionOptimizer resolveReflectionOptimizer(BytecodeProvider bytecode } private PropertyAccess makePropertyAccess(Property bootAttributeDescriptor) { - final Class mappedClass = mappedJtd.getJavaTypeClass(); + final var mappedClass = mappedJtd.getJavaTypeClass(); final String descriptorName = bootAttributeDescriptor.getName(); final var strategy = propertyAccessStrategy( bootAttributeDescriptor, mappedClass, strategySelector ); if ( strategy == null ) { diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java index 84d73fac326b..f6cda92b5aff 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java @@ -38,10 +38,8 @@ import org.hibernate.metamodel.model.domain.internal.PrimitiveBasicTypeImpl; import org.hibernate.metamodel.model.domain.spi.JpaMetamodelImplementor; import org.hibernate.metamodel.spi.RuntimeModelCreationContext; -import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.java.spi.EntityJavaType; import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; -import org.hibernate.type.descriptor.jdbc.JdbcType; import org.hibernate.type.spi.TypeConfiguration; import java.util.ArrayList; @@ -862,8 +860,8 @@ public BasicDomainType resolveBasicType(Class javaType) { } private BasicDomainType basicDomainType(Class javaType) { - final JavaType javaTypeDescriptor = getJavaTypeRegistry().resolveDescriptor( javaType ); - final JdbcType jdbcType = + final var javaTypeDescriptor = getJavaTypeRegistry().resolveDescriptor( javaType ); + final var jdbcType = javaTypeDescriptor.getRecommendedJdbcType( typeConfiguration.getCurrentBaseSqlTypeIndicators() ); return javaType.isPrimitive() ? new PrimitiveBasicTypeImpl<>( javaTypeDescriptor, jdbcType, javaType ) diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/AbstractEmbeddableMapping.java b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/AbstractEmbeddableMapping.java index 893f4cdd1d54..7294fc0a1c7a 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/AbstractEmbeddableMapping.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/AbstractEmbeddableMapping.java @@ -419,7 +419,7 @@ else if ( subtype instanceof AnyType anyType ) { attributeMapping = new DiscriminatedAssociationAttributeMapping( navigableRole.append( bootPropertyDescriptor.getName() ), - typeConfiguration.getJavaTypeRegistry().getDescriptor( Object.class ), + typeConfiguration.getJavaTypeRegistry().resolveDescriptor( Object.class ), declarer, attributeIndex, attributeIndex, diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/CompoundNaturalIdMapping.java b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/CompoundNaturalIdMapping.java index 5c50957885bf..671fbe182419 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/CompoundNaturalIdMapping.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/CompoundNaturalIdMapping.java @@ -285,10 +285,10 @@ public boolean hasPartitionedSelectionMapping() { public DomainResult createDomainResult(NavigablePath navigablePath, TableGroup tableGroup, String resultVariable, DomainResultCreationState creationState) { assert navigablePath.getLocalName().equals( NaturalIdMapping.PART_NAME ); - final JavaType jtd = + final var objectArrayJavaType = creationState.getSqlAstCreationState().getCreationContext() .getTypeConfiguration().getJavaTypeRegistry() - .getDescriptor( Object[].class ); + .resolveDescriptor( Object[].class ); // register the table group under `...{natural-id}` as well creationState.getSqlAstCreationState().getFromClauseAccess() @@ -297,7 +297,7 @@ public DomainResult createDomainResult(NavigablePath navigablePath, Table return (DomainResult) new DomainResultImpl( navigablePath, this, - jtd, + objectArrayJavaType, resultVariable, creationState ); diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/EmbeddableMappingTypeImpl.java b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/EmbeddableMappingTypeImpl.java index b613738d123c..bf9f7d845e63 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/EmbeddableMappingTypeImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/EmbeddableMappingTypeImpl.java @@ -563,7 +563,7 @@ else if ( subtype instanceof AnyType anyType ) { attributeMapping = new DiscriminatedAssociationAttributeMapping( valueMapping.getNavigableRole().append( bootPropertyDescriptor.getName() ), - typeConfiguration.getJavaTypeRegistry().getDescriptor( Object.class ), + typeConfiguration.getJavaTypeRegistry().resolveDescriptor( Object.class ), this, attributeIndex, attributeIndex, diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/MappingModelCreationHelper.java b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/MappingModelCreationHelper.java index 9e932f897108..6cf1d4f71107 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/MappingModelCreationHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/MappingModelCreationHelper.java @@ -6,7 +6,6 @@ import java.io.Serializable; import java.util.ArrayList; -import java.util.Iterator; import java.util.List; import java.util.SortedMap; import java.util.SortedSet; @@ -44,16 +43,13 @@ import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Property; import org.hibernate.mapping.Resolvable; -import org.hibernate.mapping.Selectable; import org.hibernate.mapping.SimpleValue; import org.hibernate.mapping.SortableValue; import org.hibernate.mapping.Table; import org.hibernate.mapping.ToOne; import org.hibernate.mapping.Value; import org.hibernate.metamodel.CollectionClassification; -import org.hibernate.metamodel.MappingMetamodel; import org.hibernate.metamodel.mapping.AttributeMetadata; -import org.hibernate.metamodel.mapping.BasicValuedModelPart; import org.hibernate.metamodel.mapping.CollectionIdentifierDescriptor; import org.hibernate.metamodel.mapping.CollectionMappingType; import org.hibernate.metamodel.mapping.CollectionPart; @@ -62,7 +58,6 @@ import org.hibernate.metamodel.mapping.EmbeddableValuedModelPart; import org.hibernate.metamodel.mapping.EntityIdentifierMapping; import org.hibernate.metamodel.mapping.EntityMappingType; -import org.hibernate.metamodel.mapping.ForeignKeyDescriptor; import org.hibernate.metamodel.mapping.JdbcMapping; import org.hibernate.metamodel.mapping.ManagedMappingType; import org.hibernate.metamodel.mapping.MappingType; @@ -74,10 +69,8 @@ import org.hibernate.metamodel.mapping.SelectableMapping; import org.hibernate.metamodel.mapping.SelectableMappings; import org.hibernate.metamodel.mapping.SelectablePath; -import org.hibernate.metamodel.mapping.ValuedModelPart; import org.hibernate.metamodel.mapping.VirtualModelPart; import org.hibernate.metamodel.model.domain.NavigableRole; -import org.hibernate.metamodel.spi.RuntimeModelCreationContext; import org.hibernate.persister.collection.CollectionPersister; import org.hibernate.persister.entity.EntityPersister; import org.hibernate.property.access.internal.ChainedPropertyAccessImpl; @@ -105,7 +98,6 @@ import org.hibernate.sql.results.graph.FetchParent; import org.hibernate.type.AssociationType; import org.hibernate.type.BasicType; -import org.hibernate.type.CollectionType; import org.hibernate.type.ComponentType; import org.hibernate.type.CompositeType; import org.hibernate.type.EntityType; @@ -114,7 +106,6 @@ import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan; import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.java.MutabilityPlan; -import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; import org.checkerframework.checker.nullness.qual.Nullable; @@ -145,16 +136,16 @@ public static EntityIdentifierMapping buildEncapsulatedCompositeIdentifierMappin String[] rootTableKeyColumnNames, CompositeType cidType, MappingModelCreationProcess creationProcess) { - final PersistentClass bootEntityDescriptor = + final var bootEntityDescriptor = creationProcess.getCreationContext().getBootModel() .getEntityBinding( entityPersister.getEntityName() ); - final PropertyAccess propertyAccess = + final var propertyAccess = entityPersister.getRepresentationStrategy() .resolvePropertyAccess( bootEntityDescriptor.getIdentifierProperty() ); - final Component component = (Component) bootProperty.getValue(); - final EmbeddableMappingTypeImpl embeddableMappingType = EmbeddableMappingTypeImpl.from( + final var component = (Component) bootProperty.getValue(); + final var embeddableMappingType = EmbeddableMappingTypeImpl.from( component, cidType, rootTableName, @@ -205,7 +196,7 @@ public static BasicAttributeMapping buildBasicAttributeMapping( int fetchableIndex, Property bootProperty, ManagedMappingType declaringType, - BasicType attrType, + BasicType attrType, String tableExpression, String attrColumnName, SelectablePath selectablePath, @@ -282,9 +273,9 @@ public static BasicAttributeMapping buildBasicAttributeMapping( PropertyAccess propertyAccess, CascadeStyle cascadeStyle, MappingModelCreationProcess creationProcess) { - final SimpleValue value = (SimpleValue) bootProperty.getValue(); - final BasicValue.Resolution resolution = ( (Resolvable) value ).resolve(); - final SimpleAttributeMetadata attributeMetadata = + final var value = (SimpleValue) bootProperty.getValue(); + final var resolution = ( (Resolvable) value ).resolve(); + final var attributeMetadata = new SimpleAttributeMetadata( propertyAccess, resolution.getMutabilityPlan(), bootProperty, value ); final FetchTiming fetchTiming; @@ -383,7 +374,7 @@ public static EmbeddedAttributeMapping buildEmbeddedAttributeMapping( PropertyAccess propertyAccess, CascadeStyle cascadeStyle, MappingModelCreationProcess creationProcess) { - final AttributeMetadata attributeMetadataAccess = getAttributeMetadata( + final var attributeMetadataAccess = getAttributeMetadata( bootProperty, attrType, propertyAccess, @@ -396,8 +387,8 @@ public static EmbeddedAttributeMapping buildEmbeddedAttributeMapping( componentValue = dependantValue.getWrappedValue(); } - final Component component = (Component) componentValue; - final EmbeddableMappingTypeImpl embeddableMappingType = EmbeddableMappingTypeImpl.from( + final var component = (Component) componentValue; + final var embeddableMappingType = EmbeddableMappingTypeImpl.from( component, attrType, tableExpression, @@ -544,22 +535,22 @@ public static PluralAttributeMapping buildPluralAttributeMapping( MappingModelCreationProcess creationProcess, Function mappingConverter) { - final Collection bootValueMapping = (Collection) bootProperty.getValue(); + final var bootValueMapping = (Collection) bootProperty.getValue(); - final RuntimeModelCreationContext creationContext = creationProcess.getCreationContext(); - final Dialect dialect = creationContext.getDialect(); - final MappingMetamodel domainModel = creationContext.getDomainModel(); + final var creationContext = creationProcess.getCreationContext(); + final var dialect = creationContext.getDialect(); + final var domainModel = creationContext.getDomainModel(); - final CollectionPersister collectionDescriptor = domainModel.findCollectionDescriptor( bootValueMapping.getRole() ); + final var collectionDescriptor = domainModel.findCollectionDescriptor( bootValueMapping.getRole() ); assert collectionDescriptor != null; final String tableExpression = collectionDescriptor.getTableName(); final String sqlAliasStem = SqlAliasStemHelper.INSTANCE.generateStemFromAttributeName( bootProperty.getName() ); - final JavaTypeRegistry jtdRegistry = creationContext.getJavaTypeRegistry(); + final var jtdRegistry = creationContext.getJavaTypeRegistry(); - final CollectionPart elementDescriptor = interpretElement( + final var elementDescriptor = interpretElement( bootValueMapping, tableExpression, collectionDescriptor, @@ -571,7 +562,7 @@ public static PluralAttributeMapping buildPluralAttributeMapping( final CollectionPart indexDescriptor; CollectionIdentifierDescriptor identifierDescriptor = null; - final CollectionSemantics collectionSemantics = collectionDescriptor.getCollectionSemantics(); + final var collectionSemantics = collectionDescriptor.getCollectionSemantics(); final CollectionMappingType collectionMappingType; switch ( collectionSemantics.getCollectionClassification() ) { case ARRAY: { @@ -580,8 +571,8 @@ public static PluralAttributeMapping buildPluralAttributeMapping( StandardArraySemantics.INSTANCE ); - final BasicValue index = (BasicValue) ( (IndexedCollection) bootValueMapping ).getIndex(); - final SelectableMapping selectableMapping = SelectableMappingImpl.from( + final var index = (BasicValue) ( (IndexedCollection) bootValueMapping ).getIndex(); + final var selectableMapping = SelectableMappingImpl.from( tableExpression, index.getSelectables().get(0), creationContext.getTypeConfiguration().getBasicTypeForJavaType( Integer.class ), @@ -632,8 +623,8 @@ public static PluralAttributeMapping buildPluralAttributeMapping( break; } case LIST: { - final BasicValue index = (BasicValue) ( (IndexedCollection) bootValueMapping ).getIndex(); - final SelectableMapping selectableMapping = SelectableMappingImpl.from( + final var index = (BasicValue) ( (IndexedCollection) bootValueMapping ).getIndex(); + final var selectableMapping = SelectableMappingImpl.from( tableExpression, index.getSelectables().get(0), creationContext.getTypeConfiguration().getBasicTypeForJavaType( Integer.class ), @@ -707,7 +698,7 @@ public static PluralAttributeMapping buildPluralAttributeMapping( } } - final SimpleAttributeMetadata attributeMetadata = new SimpleAttributeMetadata( + final var attributeMetadata = new SimpleAttributeMetadata( propertyAccess, ImmutableMutabilityPlan.instance(), bootProperty.isOptional(), @@ -718,24 +709,24 @@ public static PluralAttributeMapping buildPluralAttributeMapping( cascadeStyle ); - final SessionFactoryImplementor sessionFactory = creationContext.getSessionFactory(); - final CollectionType collectionType = collectionDescriptor.getCollectionType(); + final var sessionFactory = creationContext.getSessionFactory(); + final var collectionType = collectionDescriptor.getCollectionType(); - final FetchStyle style = FetchOptionsHelper.determineFetchStyleByMetadata( + final var fetchStyle = FetchOptionsHelper.determineFetchStyleByMetadata( fetchMode, collectionType, sessionFactory ); - final FetchTiming timing = determineFetchTiming( - style, + final var fetchTiming = determineFetchTiming( + fetchStyle, collectionType, collectionDescriptor.isLazy(), collectionDescriptor.getRole(), sessionFactory ); - final PluralAttributeMappingImpl pluralAttributeMapping = mappingConverter.apply( new PluralAttributeMappingImpl( + final var pluralAttributeMapping = mappingConverter.apply( new PluralAttributeMappingImpl( attrName, bootValueMapping, propertyAccess, @@ -746,8 +737,8 @@ public static PluralAttributeMapping buildPluralAttributeMapping( elementDescriptor, indexDescriptor, identifierDescriptor, - timing, - style, + fetchTiming, + fetchStyle, cascadeStyle, declaringType, collectionDescriptor, @@ -796,8 +787,9 @@ private static void interpretPluralAttributeMappingKeyDescriptor( attributeMappingSubPart = null; } else { - final ModelPartContainer partMappingType = - (ModelPartContainer) attributeMapping.getElementDescriptor().getPartMappingType(); + final var partMappingType = + (ModelPartContainer) + attributeMapping.getElementDescriptor().getPartMappingType(); attributeMappingSubPart = partMappingType.findSubPart( collectionDescriptor.getMappedByProperty(), null ); } @@ -820,7 +812,7 @@ private static void interpretPluralAttributeMappingKeyDescriptor( final boolean isReferenceToPrimaryKey = lhsPropertyName == null; final String collectionTableName = collectionDescriptor.getTableName(); - final ManagedMappingType keyDeclaringType = + final var keyDeclaringType = collectionDescriptor.getElementType() instanceof EntityType ? collectionDescriptor.getElementPersister() // This is not "really correct" but it is as good as it gets. @@ -829,7 +821,7 @@ private static void interpretPluralAttributeMappingKeyDescriptor( // Since the declaring type is needed for certain operations, we use the one from the target side of the FK : declaringType; - final ModelPart fkTargetPart = + final var fkTargetPart = isReferenceToPrimaryKey ? collectionDescriptor.getOwnerEntityPersister().getIdentifierMappingForJoin() : declaringType.findContainingEntityMapping().findSubPart( lhsPropertyName ); @@ -837,10 +829,10 @@ private static void interpretPluralAttributeMappingKeyDescriptor( if ( keyType instanceof BasicType ) { assert bootValueMappingKey.getColumnSpan() == 1; - final BasicValuedModelPart simpleFkTargetPart = castNonNull( fkTargetPart.asBasicValuedModelPart() ); + final var simpleFkTargetPart = castNonNull( fkTargetPart.asBasicValuedModelPart() ); final String keyTableExpression = collectionTableName;//getTableIdentifierExpression( bootValueMappingKey.getTable(), creationProcess ); - final SelectableMapping keySelectableMapping = SelectableMappingImpl.from( + final var keySelectableMapping = SelectableMappingImpl.from( keyTableExpression, bootValueMappingKey.getSelectables().get(0), (JdbcMapping) keyType, @@ -853,7 +845,7 @@ private static void interpretPluralAttributeMappingKeyDescriptor( creationProcess.getCreationContext() ); - final SimpleForeignKeyDescriptor keyDescriptor = new SimpleForeignKeyDescriptor( + final var keyDescriptor = new SimpleForeignKeyDescriptor( keyDeclaringType, keySelectableMapping, simpleFkTargetPart, @@ -864,7 +856,7 @@ private static void interpretPluralAttributeMappingKeyDescriptor( creationProcess.registerForeignKey( collectionDescriptor.getAttributeMapping(), keyDescriptor ); } else if ( fkTargetPart instanceof EmbeddableValuedModelPart embeddableValuedModelPart ) { - final EmbeddedForeignKeyDescriptor keyDescriptor = buildEmbeddableForeignKeyDescriptor( + final var keyDescriptor = buildEmbeddableForeignKeyDescriptor( embeddableValuedModelPart, bootValueMapping, keyDeclaringType, @@ -941,7 +933,7 @@ public static boolean interpretToOneKeyDescriptor( ); } - final ModelPart modelPart = referencedEntityDescriptor.findByPath( referencedPropertyName ); + final var modelPart = referencedEntityDescriptor.findByPath( referencedPropertyName ); if ( modelPart == null ) { throw new IllegalArgumentException( "Unable to find attribute " + bootProperty.getPersistentClass() .getEntityName() + " -> " + bootProperty.getName() ); @@ -957,7 +949,7 @@ else if ( modelPart instanceof ToOneAttributeMapping toOneAttributeMapping ) { ); } else if ( modelPart instanceof EmbeddableValuedModelPart embeddableValuedModelPart ) { - final EmbeddedForeignKeyDescriptor embeddedForeignKeyDescriptor = buildEmbeddableForeignKeyDescriptor( + final var embeddedForeignKeyDescriptor = buildEmbeddableForeignKeyDescriptor( embeddableValuedModelPart, bootValueMapping, attributeMapping.getDeclaringType(), @@ -980,21 +972,21 @@ else if ( modelPart instanceof EmbeddableValuedModelPart embeddableValuedModelPa return true; } - final ModelPart fkTarget = + final var fkTarget = bootValueMapping.isReferenceToPrimaryKey() ? referencedEntityDescriptor.getIdentifierMappingForJoin() : referencedEntityDescriptor.findByPath( bootValueMapping.getReferencedPropertyName() ); - final BasicValuedModelPart simpleFkTarget = fkTarget.asBasicValuedModelPart(); + final var simpleFkTarget = fkTarget.asBasicValuedModelPart(); if ( simpleFkTarget != null ) { - final Iterator columnIterator = bootValueMapping.getSelectables().iterator(); - final Table table = bootValueMapping.getTable(); + final var columnIterator = bootValueMapping.getSelectables().iterator(); + final var table = bootValueMapping.getTable(); final String tableExpression = getTableIdentifierExpression( table, creationProcess ); final PropertyAccess declaringKeyPropertyAccess; if ( inversePropertyAccess == null ) { // So far, OneToOne mappings are only supported based on the owner's PK if ( bootValueMapping instanceof OneToOne ) { - final EntityIdentifierMapping identifierMapping = + final var identifierMapping = attributeMapping.findContainingEntityMapping().getIdentifierMapping(); declaringKeyPropertyAccess = ( (PropertyBasedMapping) identifierMapping ).getPropertyAccess(); } @@ -1011,7 +1003,7 @@ else if ( modelPart instanceof EmbeddableValuedModelPart embeddableValuedModelPa ( (PropertyBasedMapping) simpleFkTarget ).getPropertyAccess() ); } - final SelectablePath parentSelectablePath = getSelectablePath( attributeMapping.getDeclaringType() ); + final var parentSelectablePath = getSelectablePath( attributeMapping.getDeclaringType() ); final SelectableMapping keySelectableMapping; int i = 0; final Value value = bootProperty.getValue(); @@ -1024,7 +1016,7 @@ else if ( modelPart instanceof EmbeddableValuedModelPart embeddableValuedModelPa creationProcess.getCreationContext().getTypeConfiguration(), value.isColumnInsertable( i ), value.isColumnUpdateable( i ), - ((SimpleValue) value).isPartitionKey(), + value.isPartitionKey(), dialect, creationProcess.getSqmFunctionRegistry(), creationProcess.getCreationContext() @@ -1041,14 +1033,14 @@ else if ( modelPart instanceof EmbeddableValuedModelPart embeddableValuedModelPa creationProcess.getCreationContext().getTypeConfiguration(), value.isColumnInsertable( 0 ), value.isColumnUpdateable( 0 ), - ((SimpleValue) value).isPartitionKey(), + value.isPartitionKey(), dialect, creationProcess.getSqmFunctionRegistry(), creationProcess.getCreationContext() ); } - final ForeignKeyDescriptor foreignKeyDescriptor = new SimpleForeignKeyDescriptor( + final var foreignKeyDescriptor = new SimpleForeignKeyDescriptor( attributeMapping.getDeclaringType(), keySelectableMapping, declaringKeyPropertyAccess, @@ -1109,7 +1101,7 @@ private static boolean interpretNestedToOneKeyDescriptor( for ( int i = 0; i < propertyPath.length; i++ ) { final String path = propertyPath[i]; - final ModelPart modelPart = i == 0 + final var modelPart = i == 0 ? referencedEntityDescriptor.findSubPart( path ) : lastEmbeddableModelPart.findSubPart( path, null ); @@ -1117,7 +1109,7 @@ private static boolean interpretNestedToOneKeyDescriptor( return false; } else if ( modelPart instanceof ToOneAttributeMapping referencedAttributeMapping ) { - final ForeignKeyDescriptor foreignKeyDescriptor = referencedAttributeMapping.getForeignKeyDescriptor(); + final var foreignKeyDescriptor = referencedAttributeMapping.getForeignKeyDescriptor(); if ( foreignKeyDescriptor == null ) { return false; } @@ -1173,7 +1165,7 @@ private static EmbeddedForeignKeyDescriptor buildEmbeddableForeignKeyDescriptor( boolean[] updateable, Dialect dialect, MappingModelCreationProcess creationProcess) { - final SelectablePath parentSelectablePath = getSelectablePath( keyDeclaringType ); + final var parentSelectablePath = getSelectablePath( keyDeclaringType ); final boolean hasConstraint; final SelectableMappings keySelectableMappings; if ( bootValueMapping instanceof Collection collectionBootValueMapping ) { @@ -1264,17 +1256,17 @@ private static EmbeddedForeignKeyDescriptor buildEmbeddableForeignKeyDescriptor( } public static int[] getPropertyOrder(Value bootValueMapping, MappingModelCreationProcess creationProcess) { - final RuntimeModelCreationContext creationContext = creationProcess.getCreationContext(); + final var creationContext = creationProcess.getCreationContext(); final ComponentType componentType; final boolean sorted; if ( bootValueMapping instanceof Collection collectionBootValueMapping ) { componentType = (ComponentType) collectionBootValueMapping.getKey().getType(); - final SortableValue key = (SortableValue) collectionBootValueMapping.getKey(); + final var key = (SortableValue) collectionBootValueMapping.getKey(); assert key.isSorted(); sorted = key.isSorted(); } else { - final EntityType entityType = (EntityType) bootValueMapping.getType(); + final var entityType = (EntityType) bootValueMapping.getType(); final Type identifierOrUniqueKeyType = entityType.getIdentifierOrUniqueKeyType( creationContext.getMetadata() ); if ( identifierOrUniqueKeyType instanceof ComponentType composite ) { @@ -1316,12 +1308,12 @@ private static void setReferencedAttributeForeignKeyDescriptor( String referencedPropertyName, Dialect dialect, MappingModelCreationProcess creationProcess) { - ForeignKeyDescriptor foreignKeyDescriptor = referencedAttributeMapping.getForeignKeyDescriptor(); + var foreignKeyDescriptor = referencedAttributeMapping.getForeignKeyDescriptor(); if ( foreignKeyDescriptor == null ) { - final PersistentClass entityBinding = + final var entityBinding = creationProcess.getCreationContext().getBootModel() .getEntityBinding( referencedEntityDescriptor.getEntityName() ); - final Property property = entityBinding.getRecursiveProperty( referencedPropertyName ); + final var property = entityBinding.getRecursiveProperty( referencedPropertyName ); interpretToOneKeyDescriptor( referencedAttributeMapping, property, @@ -1333,8 +1325,8 @@ private static void setReferencedAttributeForeignKeyDescriptor( foreignKeyDescriptor = referencedAttributeMapping.getForeignKeyDescriptor(); } - final EntityMappingType declaringEntityMapping = attributeMapping.findContainingEntityMapping(); - final ValuedModelPart targetPart = foreignKeyDescriptor.getTargetPart(); + final var declaringEntityMapping = attributeMapping.findContainingEntityMapping(); + final var targetPart = foreignKeyDescriptor.getTargetPart(); if ( targetPart instanceof EntityIdentifierMapping && targetPart != declaringEntityMapping.getIdentifierMapping() ) { // If the many-to-one refers to the super type, but the one-to-many is defined in a subtype, @@ -1372,8 +1364,8 @@ private static CollectionPart interpretMapKey( Dialect dialect, MappingModelCreationProcess creationProcess) { assert bootValueMapping instanceof IndexedCollection; - final IndexedCollection indexedCollection = (IndexedCollection) bootValueMapping; - final Value bootMapKeyDescriptor = indexedCollection.getIndex(); + final var indexedCollection = (IndexedCollection) bootValueMapping; + final var bootMapKeyDescriptor = indexedCollection.getIndex(); if ( bootMapKeyDescriptor instanceof BasicValue basicValue ) { final boolean insertable; @@ -1388,7 +1380,7 @@ private static CollectionPart interpretMapKey( insertable = updatable = basicValue.isColumnInsertable( 0 ) || basicValue.isColumnUpdateable( 0 ); } - final SelectableMapping selectableMapping = SelectableMappingImpl.from( + final var selectableMapping = SelectableMappingImpl.from( tableExpression, basicValue.getSelectables().get( 0 ), basicValue.resolve().getJdbcMapping(), @@ -1408,8 +1400,8 @@ private static CollectionPart interpretMapKey( } if ( bootMapKeyDescriptor instanceof Component component ) { - final CompositeType compositeType = component.getType(); - final EmbeddableMappingTypeImpl mappingType = EmbeddableMappingTypeImpl.from( + final var compositeType = component.getType(); + final var mappingType = EmbeddableMappingTypeImpl.from( component, compositeType, component.getColumnInsertability(), @@ -1429,8 +1421,8 @@ private static CollectionPart interpretMapKey( } if ( bootMapKeyDescriptor instanceof OneToMany || bootMapKeyDescriptor instanceof ToOne ) { - final EntityType indexEntityType = (EntityType) collectionDescriptor.getIndexType(); - final EntityPersister associatedEntity = + final var indexEntityType = (EntityType) collectionDescriptor.getIndexType(); + final var associatedEntity = creationProcess.getEntityPersister( indexEntityType.getAssociatedEntityName() ); final EntityCollectionPart indexDescriptor; @@ -1481,7 +1473,7 @@ private static CollectionPart interpretElement( final Value element = bootDescriptor.getElement(); if ( element instanceof BasicValue basicElement ) { - final SelectableMapping selectableMapping = SelectableMappingImpl.from( + final var selectableMapping = SelectableMappingImpl.from( tableExpression, basicElement.getSelectables().get(0), basicElement.resolve().getJdbcMapping(), @@ -1502,8 +1494,8 @@ private static CollectionPart interpretElement( } if ( element instanceof Component component ) { - final CompositeType compositeType = (CompositeType) collectionDescriptor.getElementType(); - final EmbeddableMappingTypeImpl mappingType = EmbeddableMappingTypeImpl.from( + final var compositeType = (CompositeType) collectionDescriptor.getElementType(); + final var mappingType = EmbeddableMappingTypeImpl.from( component, compositeType, component.getColumnInsertability(), @@ -1523,13 +1515,11 @@ private static CollectionPart interpretElement( } if ( element instanceof Any anyBootMapping ) { - final JavaTypeRegistry jtdRegistry = - creationProcess.getCreationContext().getTypeConfiguration() - .getJavaTypeRegistry(); return new DiscriminatedCollectionPart( CollectionPart.Nature.ELEMENT, collectionDescriptor, - jtdRegistry.getDescriptor(Object.class), + creationProcess.getCreationContext().getTypeConfiguration() + .getJavaTypeRegistry().resolveDescriptor( Object.class ), anyBootMapping, anyBootMapping.getType(), creationProcess @@ -1590,7 +1580,7 @@ public static EmbeddedAttributeMapping createInverseModelPart( TableGroupProducer declaringTableGroupProducer, SelectableMappings selectableMappings, MappingModelCreationProcess creationProcess) { - final EmbeddableMappingType embeddableTypeDescriptor = modelPart.getEmbeddableTypeDescriptor(); + final var embeddableTypeDescriptor = modelPart.getEmbeddableTypeDescriptor(); if ( modelPart instanceof NonAggregatedIdentifierMapping nonAggregatedIdentifierMapping ) { return new InverseNonAggregatedIdentifierMapping( keyDeclaringType, @@ -1653,7 +1643,7 @@ public static Expression buildColumnReferenceExpression( return new SqlTuple( columnReferences, modelPart ); } else { - final BasicValuedModelPart basicPart = castNonNull( modelPart.asBasicValuedModelPart() ); + final var basicPart = castNonNull( modelPart.asBasicValuedModelPart() ); final String qualifier = tableGroup == null ? basicPart.getContainingTableExpression() @@ -1676,9 +1666,9 @@ public static BasicType resolveAggregateColumnBasicType( NavigableRole navigableRole, Column column) { if ( column instanceof AggregateColumn aggregateColumn ) { - final Component component = aggregateColumn.getComponent(); - final NavigableRole embeddableRole = navigableRole.append( CollectionPart.Nature.ELEMENT.getName() ); - final EmbeddableMappingTypeImpl mappingType = EmbeddableMappingTypeImpl.from( + final var component = aggregateColumn.getComponent(); + final var embeddableRole = navigableRole.append( CollectionPart.Nature.ELEMENT.getName() ); + final var mappingType = EmbeddableMappingTypeImpl.from( component, component.getType(), component.getColumnInsertability(), @@ -1890,17 +1880,17 @@ public static ToOneAttributeMapping buildSingularAssociationAttributeMapping( MappingModelCreationProcess creationProcess, Function mappingConverter) { if ( bootProperty.getValue() instanceof ToOne value ) { - final EntityPersister entityPersister = creationProcess.getEntityPersister( value.getReferencedEntityName() ); - final AttributeMetadata attributeMetadata = getAttributeMetadata( + final var entityPersister = creationProcess.getEntityPersister( value.getReferencedEntityName() ); + final var attributeMetadata = getAttributeMetadata( bootProperty, attrType, propertyAccess, cascadeStyle, creationProcess ); - final SessionFactoryImplementor sessionFactory = creationProcess.getCreationContext().getSessionFactory(); + final var sessionFactory = creationProcess.getCreationContext().getSessionFactory(); - final AssociationType type = (AssociationType) bootProperty.getType(); + final var type = (AssociationType) bootProperty.getType(); final FetchStyle fetchStyle = FetchOptionsHelper .determineFetchStyleByMetadata( bootProperty.getValue().getFetchMode(), @@ -1940,7 +1930,7 @@ else if ( !lazy fetchTiming = determineFetchTiming( fetchStyle, type, lazy, role, sessionFactory ); } - final ToOneAttributeMapping attributeMapping = mappingConverter.apply( new ToOneAttributeMapping( + final var attributeMapping = mappingConverter.apply( new ToOneAttributeMapping( attrName, navigableRole, stateArrayPosition, diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java b/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java index 0be4804e8eb6..690901e3ddce 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java @@ -355,7 +355,7 @@ public JavaType getJavaConstantType(String className, String fieldName) { final Field referencedField = getJavaField( className, fieldName ); if ( referencedField != null ) { return getTypeConfiguration().getJavaTypeRegistry() - .getDescriptor( referencedField.getType() ); + .resolveDescriptor( referencedField.getType() ); } } catch (NoSuchFieldException e) { @@ -577,13 +577,13 @@ public EntityDomainType resolveEntityReference(Class javaType) { // if we found any matching, create the virtual root EntityDomainType reference if ( !matchingDescriptors.isEmpty() ) { - final SqmPolymorphicRootDescriptor descriptor = new SqmPolymorphicRootDescriptor<>( + final var polymorphicRootDescriptor = new SqmPolymorphicRootDescriptor<>( typeConfiguration.getJavaTypeRegistry().resolveDescriptor( javaType ), matchingDescriptors, this ); - polymorphicEntityReferenceMap.putIfAbsent( javaType, descriptor ); - return descriptor; + polymorphicEntityReferenceMap.putIfAbsent( javaType, polymorphicRootDescriptor ); + return polymorphicRootDescriptor; } } diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/MappingMetamodelImpl.java b/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/MappingMetamodelImpl.java index 3fd9068f13ad..ad7059bbc1b3 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/MappingMetamodelImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/MappingMetamodelImpl.java @@ -568,7 +568,7 @@ else if ( sqmExpressible instanceof BasicType basicType ) { else if ( sqmExpressible instanceof BasicDomainType ) { return getTypeConfiguration() - .getBasicTypeForJavaType( sqmExpressible.getRelationalJavaType().getJavaType() ); + .getBasicTypeForJavaType( sqmExpressible.getRelationalJavaType().getJavaTypeClass() ); } else if ( sqmExpressible instanceof BasicSqmPathSource @@ -667,8 +667,8 @@ public BindableType resolveParameterBindType(Class javaType) { if ( javaType.isArray() && javaTypeRegistry.findDescriptor( javaType.getComponentType() ) != null ) { - final JavaType resolvedJavaType = javaTypeRegistry.resolveDescriptor( javaType ); - final JdbcType recommendedJdbcType = + final var resolvedJavaType = javaTypeRegistry.resolveDescriptor( javaType ); + final var recommendedJdbcType = resolvedJavaType.getRecommendedJdbcType( typeConfiguration.getCurrentBaseSqlTypeIndicators() ); if ( recommendedJdbcType != null ) { return typeConfiguration.getBasicTypeRegistry().resolve( resolvedJavaType, recommendedJdbcType ); diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/PluralAttributeBuilder.java b/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/PluralAttributeBuilder.java index c920d05e358e..a47add5cdde1 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/PluralAttributeBuilder.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/PluralAttributeBuilder.java @@ -69,9 +69,9 @@ public static PersistentAttribute build( boolean isGeneric, MetadataContext metadataContext) { - final JavaType attributeJtd = + final var attributeJtd = metadataContext.getTypeConfiguration().getJavaTypeRegistry() - .getDescriptor( attributeMetadata.getJavaType() ); + .resolveDescriptor( attributeMetadata.getJavaType() ); final var builder = new PluralAttributeBuilder<>( attributeJtd, diff --git a/hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java b/hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java index bdf1a9aef57c..e82437d18bb7 100644 --- a/hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java +++ b/hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java @@ -5369,9 +5369,9 @@ protected AttributeMapping generateNonIdAttributeMapping( ); } else if ( attrType instanceof AnyType anyType ) { - final JavaType baseAssociationJtd = + final var baseAssociationJtd = creationContext.getTypeConfiguration().getJavaTypeRegistry() - .getDescriptor( Object.class ); + .resolveDescriptor( Object.class ); final MutabilityPlan mutabilityPlan = new DiscriminatedAssociationAttributeMapping.MutabilityPlanImpl( anyType ); diff --git a/hibernate-core/src/main/java/org/hibernate/procedure/internal/Util.java b/hibernate-core/src/main/java/org/hibernate/procedure/internal/Util.java index fba4a0af639b..9145aaf77bca 100644 --- a/hibernate-core/src/main/java/org/hibernate/procedure/internal/Util.java +++ b/hibernate-core/src/main/java/org/hibernate/procedure/internal/Util.java @@ -14,7 +14,6 @@ import org.hibernate.query.named.NamedObjectRepository; import org.hibernate.query.named.NamedResultSetMappingMemento; import org.hibernate.query.results.ResultSetMapping; -import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; /** @@ -84,7 +83,7 @@ public static void resolveResultSetMappingClasses( } } else { - final JavaType basicType = javaTypeRegistry.getDescriptor( resultSetMappingClass ); + final var basicType = javaTypeRegistry.resolveDescriptor( resultSetMappingClass ); if ( basicType != null ) { resultSetMapping.addResultBuilder( new ScalarDomainResultBuilder<>( basicType ) ); } diff --git a/hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java b/hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java index 5ebb76db1291..c8eb578979c6 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java +++ b/hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java @@ -396,8 +396,8 @@ private SemanticQueryBuilder( final TypeConfiguration typeConfiguration = creationContext.getTypeConfiguration(); final JavaTypeRegistry javaTypeRegistry = typeConfiguration.getJavaTypeRegistry(); this.integerDomainType = typeConfiguration.standardBasicTypeForJavaType( Integer.class ); - this.listJavaType = javaTypeRegistry.resolveDescriptor( List.class ); - this.mapJavaType = javaTypeRegistry.resolveDescriptor( Map.class ); + this.listJavaType = javaTypeRegistry.getDescriptor( List.class ); + this.mapJavaType = javaTypeRegistry.getDescriptor( Map.class ); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/query/internal/ResultMementoBasicStandard.java b/hibernate-core/src/main/java/org/hibernate/query/internal/ResultMementoBasicStandard.java index 6fae48ddbdbd..8acb99602485 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/internal/ResultMementoBasicStandard.java +++ b/hibernate-core/src/main/java/org/hibernate/query/internal/ResultMementoBasicStandard.java @@ -71,7 +71,7 @@ public ResultMementoBasicStandard( ResultSetMappingResolutionContext context) { this.explicitColumnName = definition.name(); - final Class definedType = definition.type(); + final var definedType = definition.type(); if ( void.class == definedType ) { builder = new CompleteResultBuilderBasicValuedStandard( explicitColumnName, null, null ); } @@ -81,14 +81,11 @@ public ResultMementoBasicStandard( if ( AttributeConverter.class.isAssignableFrom( definedType ) ) { @SuppressWarnings("unchecked") - final Class> converterClass = - (Class>) definedType; - final ManagedBean> converterBean = - managedBeanRegistry.getBean( converterClass ); - final JavaType> converterJtd = - typeConfiguration.getJavaTypeRegistry().getDescriptor( converterClass ); - - final ParameterizedType parameterizedType = + final var converterClass = (Class>) definedType; + final var converterBean = managedBeanRegistry.getBean( converterClass ); + final var converterJtd = typeConfiguration.getJavaTypeRegistry().resolveDescriptor( converterClass ); + + final var parameterizedType = extractAttributeConverterParameterizedType( converterBean.getBeanClass() ); builder = new CompleteResultBuilderBasicValuedConverted( @@ -104,15 +101,15 @@ public ResultMementoBasicStandard( final JavaType explicitJavaType; // see if this is a registered BasicType... - final BasicType registeredBasicType = + final BasicType registeredBasicType = typeConfiguration.getBasicTypeRegistry().getRegisteredType( definedType.getName() ); if ( registeredBasicType != null ) { explicitType = registeredBasicType; explicitJavaType = registeredBasicType.getJavaTypeDescriptor(); } else { - final JavaTypeRegistry jtdRegistry = typeConfiguration.getJavaTypeRegistry(); - final JavaType registeredJtd = jtdRegistry.getDescriptor( definedType ); + final var jtdRegistry = typeConfiguration.getJavaTypeRegistry(); + final var registeredJtd = jtdRegistry.resolveDescriptor( definedType ); if ( BasicType.class.isAssignableFrom( registeredJtd.getJavaTypeClass() ) ) { final ManagedBean> typeBean = (ManagedBean) managedBeanRegistry.getBean( registeredJtd.getJavaTypeClass() ); @@ -128,7 +125,7 @@ else if ( UserType.class.isAssignableFrom( registeredJtd.getJavaTypeClass() ) ) } else { explicitType = null; - explicitJavaType = jtdRegistry.getDescriptor( definedType ); + explicitJavaType = jtdRegistry.resolveDescriptor( definedType ); } } @@ -140,18 +137,17 @@ else if ( UserType.class.isAssignableFrom( registeredJtd.getJavaTypeClass() ) ) private BasicJavaType determineDomainJavaType( ParameterizedType parameterizedType, JavaTypeRegistry jtdRegistry) { - final java.lang.reflect.Type[] typeParameters = parameterizedType.getActualTypeArguments(); - final java.lang.reflect.Type domainTypeType = typeParameters[ 0 ]; - final Class domainClass = (Class) domainTypeType; - - return (BasicJavaType) jtdRegistry.getDescriptor( domainClass ); + final var typeParameters = parameterizedType.getActualTypeArguments(); + final var domainTypeType = typeParameters[ 0 ]; + final var domainClass = (Class) domainTypeType; + return (BasicJavaType) jtdRegistry.resolveDescriptor( domainClass ); } private BasicValuedMapping resolveUnderlyingMapping( ParameterizedType parameterizedType, TypeConfiguration typeConfiguration) { - final java.lang.reflect.Type[] typeParameters = parameterizedType.getActualTypeArguments(); - return typeConfiguration.standardBasicTypeForJavaType( (Class) typeParameters[ 1 ] ); + final var typeParameters = parameterizedType.getActualTypeArguments(); + return typeConfiguration.standardBasicTypeForJavaType( typeParameters[ 1 ] ); } public ResultMementoBasicStandard( diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/Builders.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/Builders.java index c19380870216..80af905f3417 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/Builders.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/Builders.java @@ -48,7 +48,6 @@ import org.hibernate.sql.results.graph.Fetchable; import org.hibernate.sql.results.graph.embeddable.EmbeddableValuedFetchable; import org.hibernate.type.BasicType; -import org.hibernate.type.descriptor.java.JavaType; import jakarta.persistence.AttributeConverter; import jakarta.persistence.metamodel.EntityType; @@ -88,10 +87,9 @@ public static DynamicResultBuilderBasic scalar( String resultAlias, Class javaTypeClass, SessionFactoryImplementor factory) { - final JavaType javaType = factory.getTypeConfiguration() - .getJavaTypeRegistry() - .getDescriptor( javaTypeClass ); - + final var javaType = + factory.getTypeConfiguration().getJavaTypeRegistry() + .resolveDescriptor( javaTypeClass ); return new DynamicResultBuilderBasicStandard( columnAlias, resultAlias, javaType ); } @@ -140,9 +138,9 @@ public static ResultBuilderBasicValued scalar(int position, BasicType type) { } public static DynamicResultBuilderInstantiation instantiation(Class targetJavaType, SessionFactoryImplementor factory) { - final JavaType targetJtd = factory.getTypeConfiguration() - .getJavaTypeRegistry() - .getDescriptor( targetJavaType ); + final var targetJtd = + factory.getTypeConfiguration().getJavaTypeRegistry() + .resolveDescriptor( targetJavaType ); return new DynamicResultBuilderInstantiation<>( targetJtd ); } diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/AbstractFetchBuilderContainer.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/AbstractFetchBuilderContainer.java index 5ebf092bd581..2508f94d1967 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/AbstractFetchBuilderContainer.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/AbstractFetchBuilderContainer.java @@ -26,8 +26,8 @@ protected AbstractFetchBuilderContainer() { protected AbstractFetchBuilderContainer(AbstractFetchBuilderContainer original) { if ( original.fetchBuilderMap != null ) { fetchBuilderMap = new HashMap<>( original.fetchBuilderMap.size() ); - for ( Map.Entry entry : original.fetchBuilderMap.entrySet() ) { - final FetchBuilder fetchBuilder = + for ( var entry : original.fetchBuilderMap.entrySet() ) { + final var fetchBuilder = entry.getValue() instanceof DynamicFetchBuilderStandard dynamicFetchBuilderStandard ? dynamicFetchBuilderStandard.cacheKeyInstance( this ) : entry.getValue().cacheKeyInstance(); @@ -45,14 +45,14 @@ public FetchBuilder findFetchBuilder(Fetchable fetchable) { @Override public T addProperty(Fetchable fetchable, String columnAlias) { - final DynamicFetchBuilder fetchBuilder = addProperty( fetchable ); + final var fetchBuilder = addProperty( fetchable ); fetchBuilder.addColumnAlias( columnAlias ); return (T) this; } @Override public T addProperty(Fetchable fetchable, String... columnAliases) { - final DynamicFetchBuilder fetchBuilder = addProperty( fetchable ); + final var fetchBuilder = addProperty( fetchable ); ArrayHelper.forEach( columnAliases, fetchBuilder::addColumnAlias ); return (T) this; } @@ -63,7 +63,7 @@ public DynamicFetchBuilder addProperty(Fetchable fetchable) { fetchBuilderMap = new HashMap<>(); } else { - final FetchBuilder existing = fetchBuilderMap.get( fetchable ); + final var existing = fetchBuilderMap.get( fetchable ); if ( existing != null ) { throw new IllegalArgumentException( String.format( @@ -77,7 +77,7 @@ public DynamicFetchBuilder addProperty(Fetchable fetchable) { } } - final DynamicFetchBuilderStandard fetchBuilder = new DynamicFetchBuilderStandard( fetchable ); + final var fetchBuilder = new DynamicFetchBuilderStandard( fetchable ); fetchBuilderMap.put( fetchable, fetchBuilder ); return fetchBuilder; } @@ -99,7 +99,7 @@ public boolean equals(Object o) { return false; } - final AbstractFetchBuilderContainer that = (AbstractFetchBuilderContainer) o; + final var that = (AbstractFetchBuilderContainer) o; return Objects.equals( fetchBuilderMap, that.fetchBuilderMap ); } diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicFetchBuilderLegacy.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicFetchBuilderLegacy.java index 43db6ab612c1..621422ddac86 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicFetchBuilderLegacy.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicFetchBuilderLegacy.java @@ -7,7 +7,6 @@ import org.hibernate.AssertionFailure; import org.hibernate.LockMode; import org.hibernate.engine.FetchTiming; -import org.hibernate.metamodel.mapping.CollectionPart; import org.hibernate.metamodel.mapping.EntityAssociationMapping; import org.hibernate.metamodel.mapping.ForeignKeyDescriptor; import org.hibernate.metamodel.mapping.PluralAttributeMapping; @@ -25,7 +24,6 @@ import org.hibernate.sql.ast.SqlAstJoinType; import org.hibernate.sql.ast.spi.SqlAliasBaseConstant; import org.hibernate.sql.ast.tree.from.TableGroup; -import org.hibernate.sql.ast.tree.from.TableGroupJoin; import org.hibernate.sql.ast.tree.from.TableGroupJoinProducer; import org.hibernate.sql.ast.tree.from.TableReference; import org.hibernate.sql.results.graph.DomainResultCreationState; @@ -132,7 +130,7 @@ else if ( propertyName.equals( "element" ) ) { return pluralAttributeMapping.getElementDescriptor().getCollectionAttribute(); } else { - final CollectionPart elementDescriptor = pluralAttributeMapping.getElementDescriptor(); + final var elementDescriptor = pluralAttributeMapping.getElementDescriptor(); if ( elementDescriptor instanceof EntityCollectionPart entityCollectionPart ) { if ( propertyName.startsWith( ELEMENT_PREFIX ) ) { propertyName = propertyName.substring( ELEMENT_PREFIX_LENGTH ); @@ -167,7 +165,7 @@ private Map fetchBuilderMap() { } else { final Map fetchBuilderMap = new HashMap<>( this.fetchBuilderMap.size() ); - for ( Map.Entry entry : this.fetchBuilderMap.entrySet() ) { + for ( var entry : this.fetchBuilderMap.entrySet() ) { fetchBuilderMap.put( entry.getKey(), entry.getValue().cacheKeyInstance() ); } return fetchBuilderMap; @@ -180,9 +178,9 @@ public Fetch buildFetch( NavigablePath fetchPath, JdbcValuesMetadata jdbcResultsMetadata, DomainResultCreationState domainResultCreationState) { - final DomainResultCreationStateImpl creationState = impl( domainResultCreationState ); - final TableGroup ownerTableGroup = creationState.getFromClauseAccess().findByAlias( ownerTableAlias ); - final TableGroup tableGroup = tableGroup( fetchPath, ownerTableGroup, creationState ); + final var creationState = impl( domainResultCreationState ); + final var ownerTableGroup = creationState.getFromClauseAccess().findByAlias( ownerTableAlias ); + final var tableGroup = tableGroup( fetchPath, ownerTableGroup, creationState ); if ( lockMode != null ) { domainResultCreationState.getSqlAstCreationState().registerLockMode( tableAlias, lockMode ); } @@ -261,7 +259,7 @@ private TableGroup tableGroup( TableGroup ownerTableGroup, DomainResultCreationStateImpl creationState) { if ( fetchable instanceof TableGroupJoinProducer tableGroupJoinProducer ) { - final TableGroupJoin tableGroupJoin = tableGroupJoinProducer.createTableGroupJoin( + final var tableGroupJoin = tableGroupJoinProducer.createTableGroupJoin( fetchPath, ownerTableGroup, tableAlias, @@ -272,7 +270,7 @@ private TableGroup tableGroup( creationState ); ownerTableGroup.addTableGroupJoin( tableGroupJoin ); - final TableGroup tableGroup = tableGroupJoin.getJoinedGroup(); + final var tableGroup = tableGroupJoin.getJoinedGroup(); creationState.getFromClauseAccess().registerTableGroup( fetchPath, tableGroup ); return tableGroup; } @@ -305,7 +303,7 @@ private void resolveSqlSelection( SelectableMapping selectableMapping, JdbcValuesMetadata jdbcResultsMetadata, DomainResultCreationState domainResultCreationState) { - final DomainResultCreationStateImpl creationStateImpl = impl( domainResultCreationState ); + final var creationStateImpl = impl( domainResultCreationState ); creationStateImpl.resolveSqlSelection( ResultsHelper.resolveSqlExpression( creationStateImpl, @@ -333,7 +331,7 @@ public List getColumnAliases() { @Override public DynamicFetchBuilder addProperty(Fetchable fetchable) { - DynamicFetchBuilderStandard fetchBuilder = new DynamicFetchBuilderStandard( fetchable ); + var fetchBuilder = new DynamicFetchBuilderStandard( fetchable ); fetchBuilderMap.put( fetchable, fetchBuilder ); return fetchBuilder; } @@ -345,14 +343,14 @@ public FetchBuilder findFetchBuilder(Fetchable fetchable) { @Override public DynamicFetchBuilderContainer addProperty(Fetchable fetchable, String columnAlias) { - final DynamicFetchBuilder fetchBuilder = addProperty( fetchable ); + final var fetchBuilder = addProperty( fetchable ); fetchBuilder.addColumnAlias( columnAlias ); return this; } @Override public DynamicFetchBuilderContainer addProperty(Fetchable fetchable, String... columnAliases) { - final DynamicFetchBuilder fetchBuilder = addProperty( fetchable ); + final var fetchBuilder = addProperty( fetchable ); for ( String columnAlias : columnAliases ) { fetchBuilder.addColumnAlias( columnAlias ); } @@ -373,7 +371,7 @@ public boolean equals(Object o) { return false; } - final DynamicFetchBuilderLegacy that = (DynamicFetchBuilderLegacy) o; + final var that = (DynamicFetchBuilderLegacy) o; return tableAlias.equals( that.tableAlias ) && ownerTableAlias.equals( that.ownerTableAlias ) && fetchable.equals( that.fetchable ) diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicFetchBuilderStandard.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicFetchBuilderStandard.java index 0a2f9970a327..19bbd820ebe1 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicFetchBuilderStandard.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicFetchBuilderStandard.java @@ -6,7 +6,6 @@ import org.hibernate.AssertionFailure; import org.hibernate.engine.FetchTiming; -import org.hibernate.metamodel.mapping.BasicValuedModelPart; import org.hibernate.metamodel.mapping.PluralAttributeMapping; import org.hibernate.metamodel.mapping.SelectableConsumer; import org.hibernate.metamodel.mapping.ValuedModelPart; @@ -17,7 +16,6 @@ import org.hibernate.spi.NavigablePath; import org.hibernate.sql.ast.spi.SqlExpressionResolver; import org.hibernate.sql.ast.tree.from.TableGroup; -import org.hibernate.sql.ast.tree.from.TableReference; import org.hibernate.sql.results.graph.DomainResultCreationState; import org.hibernate.sql.results.graph.Fetch; import org.hibernate.sql.results.graph.FetchParent; @@ -69,14 +67,14 @@ public Fetch buildFetch( NavigablePath fetchPath, JdbcValuesMetadata jdbcResultsMetadata, DomainResultCreationState domainResultCreationState) { - final DomainResultCreationStateImpl creationStateImpl = ResultsHelper.impl( domainResultCreationState ); - final TableGroup ownerTableGroup = + final var creationStateImpl = ResultsHelper.impl( domainResultCreationState ); + final var ownerTableGroup = creationStateImpl.getFromClauseAccess().getTableGroup( parent.getNavigablePath() ); - final SqlExpressionResolver sqlExpressionResolver = + final var sqlExpressionResolver = domainResultCreationState.getSqlAstCreationState().getSqlExpressionResolver(); - final BasicValuedModelPart basicPart = fetchable.asBasicValuedModelPart(); + final var basicPart = fetchable.asBasicValuedModelPart(); if ( basicPart != null ) { fetchable.forEachSelectable( getSelectableConsumer( @@ -177,7 +175,7 @@ private SelectableConsumer getSelectableConsumer( SqlExpressionResolver sqlExpressionResolver, ValuedModelPart valuedModelPart) { return (selectionIndex, selectableMapping) -> { - final TableReference tableReference = ownerTableGroup.resolveTableReference( + final var tableReference = ownerTableGroup.resolveTableReference( fetchPath, valuedModelPart, selectableMapping.getContainingTableExpression() @@ -225,7 +223,7 @@ public boolean equals(Object o) { return false; } - final DynamicFetchBuilderStandard that = (DynamicFetchBuilderStandard) o; + final var that = (DynamicFetchBuilderStandard) o; return fetchable.equals( that.fetchable ) && columnNames.equals( that.columnNames ); } diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderAttribute.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderAttribute.java index ddc5b0ea4b6a..8fe16e80133b 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderAttribute.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderAttribute.java @@ -76,7 +76,7 @@ public DomainResult buildResult( JdbcValuesMetadata jdbcResultsMetadata, int resultPosition, DomainResultCreationState domainResultCreationState) { - final SqlSelection sqlSelection = + final var sqlSelection = sqlSelection( jdbcResultsMetadata, domainResultCreationState, impl( domainResultCreationState ) ); return new BasicResult<>( sqlSelection.getValuesArrayPosition(), @@ -116,11 +116,11 @@ public boolean equals(Object o) { return false; } - final DynamicResultBuilderAttribute that = (DynamicResultBuilderAttribute) o; + final var that = (DynamicResultBuilderAttribute) o; return attributeMapping.equals( that.attributeMapping ) - && columnAlias.equals( that.columnAlias ) - && entityName.equals( that.entityName ) - && attributePath.equals( that.attributePath ); + && columnAlias.equals( that.columnAlias ) + && entityName.equals( that.entityName ) + && attributePath.equals( that.attributePath ); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderBasicConverted.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderBasicConverted.java index 47cf29d63b37..7b80ff81fcf7 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderBasicConverted.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderBasicConverted.java @@ -9,18 +9,13 @@ import org.hibernate.metamodel.mapping.BasicValuedMapping; import org.hibernate.query.results.internal.ResultSetMappingSqlSelection; import org.hibernate.query.results.internal.ResultsHelper; -import org.hibernate.resource.beans.spi.ManagedBeanRegistry; import org.hibernate.resource.beans.spi.ProvidedInstanceManagedBeanImpl; -import org.hibernate.sql.ast.spi.SqlAstCreationState; import org.hibernate.sql.ast.spi.SqlExpressionResolver; -import org.hibernate.sql.ast.spi.SqlSelection; import org.hibernate.sql.results.graph.DomainResultCreationState; import org.hibernate.sql.results.graph.basic.BasicResult; import org.hibernate.sql.results.jdbc.spi.JdbcValuesMetadata; -import org.hibernate.type.BasicType; import org.hibernate.type.descriptor.converter.internal.AttributeConverterBean; import org.hibernate.type.descriptor.converter.spi.BasicValueConverter; -import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; import org.hibernate.type.spi.TypeConfiguration; import java.util.Objects; @@ -41,12 +36,14 @@ public DynamicResultBuilderBasicConverted( AttributeConverter converter, SessionFactoryImplementor sessionFactory) { this.columnAlias = columnAlias; - final JavaTypeRegistry javaTypeRegistry = sessionFactory.getTypeConfiguration().getJavaTypeRegistry(); + final var javaTypeRegistry = sessionFactory.getTypeConfiguration().getJavaTypeRegistry(); + @SuppressWarnings("unchecked") + final var converterClass = (Class>) converter.getClass(); this.basicValueConverter = new AttributeConverterBean<>( new ProvidedInstanceManagedBeanImpl<>( converter ), - javaTypeRegistry.getDescriptor( converter.getClass() ), - javaTypeRegistry.getDescriptor( domainJavaType ), - javaTypeRegistry.getDescriptor( jdbcJavaType ) + javaTypeRegistry.resolveDescriptor( converterClass ), + javaTypeRegistry.resolveDescriptor( domainJavaType ), + javaTypeRegistry.resolveDescriptor( jdbcJavaType ) ); } @@ -57,13 +54,13 @@ public DynamicResultBuilderBasicConverted( Class> converterJavaType, SessionFactoryImplementor sessionFactory) { this.columnAlias = columnAlias; - final ManagedBeanRegistry beans = sessionFactory.getManagedBeanRegistry(); - final JavaTypeRegistry javaTypeRegistry = sessionFactory.getTypeConfiguration().getJavaTypeRegistry(); + final var beans = sessionFactory.getManagedBeanRegistry(); + final var javaTypeRegistry = sessionFactory.getTypeConfiguration().getJavaTypeRegistry(); this.basicValueConverter = new AttributeConverterBean<>( beans.getBean( converterJavaType ), - javaTypeRegistry.getDescriptor( converterJavaType ), - javaTypeRegistry.getDescriptor( domainJavaType ), - javaTypeRegistry.getDescriptor( jdbcJavaType ) + javaTypeRegistry.resolveDescriptor( converterJavaType ), + javaTypeRegistry.resolveDescriptor( domainJavaType ), + javaTypeRegistry.resolveDescriptor( jdbcJavaType ) ); } @@ -82,15 +79,15 @@ public BasicResult buildResult( JdbcValuesMetadata jdbcResultsMetadata, int resultPosition, DomainResultCreationState domainResultCreationState) { - final SqlAstCreationState sqlAstCreationState = domainResultCreationState.getSqlAstCreationState(); - final TypeConfiguration typeConfiguration = sqlAstCreationState.getCreationContext().getTypeConfiguration(); - final SqlExpressionResolver sqlExpressionResolver = sqlAstCreationState.getSqlExpressionResolver(); + final var sqlAstCreationState = domainResultCreationState.getSqlAstCreationState(); + final var typeConfiguration = sqlAstCreationState.getCreationContext().getTypeConfiguration(); + final var sqlExpressionResolver = sqlAstCreationState.getSqlExpressionResolver(); final String columnName = columnAlias != null ? columnAlias : jdbcResultsMetadata.resolveColumnName( resultPosition + 1 ); - final SqlSelection sqlSelection = sqlExpressionResolver.resolveSqlSelection( + final var sqlSelection = sqlExpressionResolver.resolveSqlSelection( sqlExpressionResolver.resolveSqlExpression( SqlExpressionResolver.createColumnReferenceKey( columnName ), state -> resultSetMappingSqlSelection( jdbcResultsMetadata, resultPosition, typeConfiguration ) @@ -117,7 +114,7 @@ private ResultSetMappingSqlSelection resultSetMappingSqlSelection( columnAlias != null ? jdbcResultsMetadata.resolveColumnPosition( columnAlias ) : resultPosition + 1; - final BasicType basicType = jdbcResultsMetadata.resolveType( + final var basicType = jdbcResultsMetadata.resolveType( jdbcPosition, basicValueConverter.getRelationalJavaType(), typeConfiguration @@ -135,7 +132,7 @@ public boolean equals(Object o) { return false; } - DynamicResultBuilderBasicConverted that = (DynamicResultBuilderBasicConverted) o; + final var that = (DynamicResultBuilderBasicConverted) o; return Objects.equals( columnAlias, that.columnAlias ) && basicValueConverter.equals( that.basicValueConverter ); diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderBasicStandard.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderBasicStandard.java index bc5012c6dc62..6f7d44c6c537 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderBasicStandard.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderBasicStandard.java @@ -5,14 +5,10 @@ package org.hibernate.query.results.internal.dynamic; import org.hibernate.metamodel.mapping.BasicValuedMapping; -import org.hibernate.metamodel.mapping.JdbcMapping; import org.hibernate.query.NativeQuery; import org.hibernate.query.results.internal.ResultSetMappingSqlSelection; import org.hibernate.query.results.internal.ResultsHelper; -import org.hibernate.sql.ast.spi.SqlAstCreationState; import org.hibernate.sql.ast.spi.SqlExpressionResolver; -import org.hibernate.sql.ast.spi.SqlSelection; -import org.hibernate.sql.ast.tree.expression.Expression; import org.hibernate.sql.results.graph.DomainResultCreationState; import org.hibernate.sql.results.graph.basic.BasicResult; import org.hibernate.sql.results.jdbc.spi.JdbcValuesMetadata; @@ -119,11 +115,11 @@ public BasicResult buildResult( JdbcValuesMetadata jdbcResultsMetadata, int resultPosition, DomainResultCreationState domainResultCreationState) { - final SqlAstCreationState sqlAstCreationState = domainResultCreationState.getSqlAstCreationState(); - final TypeConfiguration typeConfiguration = sqlAstCreationState.getCreationContext().getTypeConfiguration(); - final SqlExpressionResolver sqlExpressionResolver = sqlAstCreationState.getSqlExpressionResolver(); + final var sqlAstCreationState = domainResultCreationState.getSqlAstCreationState(); + final var typeConfiguration = sqlAstCreationState.getCreationContext().getTypeConfiguration(); + final var sqlExpressionResolver = sqlAstCreationState.getSqlExpressionResolver(); - final Expression expression = sqlExpressionResolver.resolveSqlExpression( + final var expression = sqlExpressionResolver.resolveSqlExpression( SqlExpressionResolver.createColumnReferenceKey( columnName ), state -> resultSetMappingSqlSelection( jdbcResultsMetadata, typeConfiguration ) ); @@ -137,12 +133,12 @@ public BasicResult buildResult( converter = null; } else { - final JdbcMapping jdbcMapping = expression.getExpressionType().getSingleJdbcMapping(); + final var jdbcMapping = expression.getExpressionType().getSingleJdbcMapping(); javaType = jdbcMapping.getMappedJavaType(); jdbcJavaType = jdbcMapping.getJdbcJavaType(); converter = jdbcMapping.getValueConverter(); } - final SqlSelection sqlSelection = sqlExpressionResolver.resolveSqlSelection( + final var sqlSelection = sqlExpressionResolver.resolveSqlSelection( expression, jdbcJavaType, null, @@ -170,7 +166,7 @@ private ResultSetMappingSqlSelection resultSetMappingSqlSelection( ? columnPosition : jdbcResultsMetadata.resolveColumnPosition( columnName ); final int valuesArrayPosition = ResultsHelper.jdbcPositionToValuesArrayPosition( jdbcPosition ); - final BasicType basicType = + final var basicType = explicitType != null ? explicitType : jdbcResultsMetadata.resolveType( jdbcPosition, explicitJavaType, typeConfiguration ); @@ -186,7 +182,7 @@ public boolean equals(Object o) { return false; } - final DynamicResultBuilderBasicStandard that = (DynamicResultBuilderBasicStandard) o; + final var that = (DynamicResultBuilderBasicStandard) o; return columnPosition == that.columnPosition && columnName.equals( that.columnName ) && resultAlias.equals( that.resultAlias ) diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderEntityCalculated.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderEntityCalculated.java index 06478a9ed36e..a8a800a3f2a5 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderEntityCalculated.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderEntityCalculated.java @@ -7,11 +7,9 @@ import org.hibernate.LockMode; import org.hibernate.metamodel.mapping.EntityMappingType; import org.hibernate.query.NativeQuery; -import org.hibernate.query.results.internal.DomainResultCreationStateImpl; import org.hibernate.query.results.internal.ResultsHelper; import org.hibernate.spi.NavigablePath; import org.hibernate.sql.ast.spi.SqlAliasBaseConstant; -import org.hibernate.sql.ast.tree.from.TableGroup; import org.hibernate.sql.results.graph.DomainResultCreationState; import org.hibernate.sql.results.graph.entity.EntityResult; import org.hibernate.sql.results.jdbc.spi.JdbcValuesMetadata; @@ -105,9 +103,9 @@ public EntityResult buildResult( JdbcValuesMetadata jdbcResultsMetadata, int resultPosition, DomainResultCreationState domainResultCreationState) { - final DomainResultCreationStateImpl creationStateImpl = ResultsHelper.impl( domainResultCreationState ); + final var creationStateImpl = ResultsHelper.impl( domainResultCreationState ); - final TableGroup tableGroup = entityMapping.createRootTableGroup( + final var tableGroup = entityMapping.createRootTableGroup( true, navigablePath, tableAlias, @@ -138,7 +136,7 @@ public boolean equals(Object o) { return false; } - final DynamicResultBuilderEntityCalculated that = (DynamicResultBuilderEntityCalculated) o; + final var that = (DynamicResultBuilderEntityCalculated) o; return navigablePath.equals( that.navigablePath ) && entityMapping.equals( that.entityMapping ) && tableAlias.equals( that.tableAlias ) diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderEntityStandard.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderEntityStandard.java index 3abb11f99526..568c3c99f39b 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderEntityStandard.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderEntityStandard.java @@ -16,11 +16,9 @@ import org.hibernate.metamodel.mapping.internal.ManyToManyCollectionPart; import org.hibernate.query.NativeQuery; import org.hibernate.query.results.FetchBuilder; -import org.hibernate.query.results.internal.DomainResultCreationStateImpl; import org.hibernate.query.results.internal.ResultsHelper; import org.hibernate.query.results.internal.complete.CompleteFetchBuilder; import org.hibernate.spi.NavigablePath; -import org.hibernate.sql.ast.spi.FromClauseAccess; import org.hibernate.sql.ast.spi.SqlAliasBaseConstant; import org.hibernate.sql.ast.tree.from.TableGroup; import org.hibernate.sql.ast.tree.from.TableReference; @@ -172,8 +170,8 @@ private T buildResultOrFetch( Fetchable fetchable, JdbcValuesMetadata jdbcResultsMetadata, DomainResultCreationState domainResultCreationState) { - final DomainResultCreationStateImpl creationState = impl( domainResultCreationState ); - final FromClauseAccess fromClauseAccess = domainResultCreationState.getSqlAstCreationState().getFromClauseAccess(); + final var creationState = impl( domainResultCreationState ); + final var fromClauseAccess = domainResultCreationState.getSqlAstCreationState().getFromClauseAccess(); final TableGroup collectionTableGroup; final NavigablePath elementNavigablePath; if ( fetchable instanceof PluralAttributeMapping ) { @@ -200,11 +198,11 @@ private T buildResultOrFetch( ); } ); - final TableReference tableReference = tableGroup.getPrimaryTableReference(); + final var tableReference = tableGroup.getPrimaryTableReference(); final List keyColumnAliases; - final FetchBuilder idFetchBuilder = findIdFetchBuilder(); - if ( this.idColumnNames != null ) { - keyColumnAliases = this.idColumnNames; + final var idFetchBuilder = findIdFetchBuilder(); + if ( idColumnNames != null ) { + keyColumnAliases = idColumnNames; } else if ( idFetchBuilder != null ) { keyColumnAliases = ( (DynamicFetchBuilder) idFetchBuilder ).getColumnAliases(); @@ -223,7 +221,7 @@ else if ( idFetchBuilder != null ) { else { // In here, we know that the idColumnNames refer to the columns of the join table, // so we also need to resolve selections for the element identifier columns - final ManyToManyCollectionPart elementDescriptor = (ManyToManyCollectionPart) pluralAttributeMapping.getElementDescriptor(); + final var elementDescriptor = (ManyToManyCollectionPart) pluralAttributeMapping.getElementDescriptor(); keyPart = elementDescriptor.getForeignKeyDescriptor().getKeyPart(); keyTableGroup = collectionTableGroup; final List idColumnAliases; @@ -290,7 +288,7 @@ else if ( idFetchBuilder instanceof CompleteFetchBuilder completeFetchBuilder ) } private static void resolveDiscriminatorSqlSelection(String columnAlias, TableReference tableReference, EntityDiscriminatorMapping discriminatorMapping, JdbcValuesMetadata jdbcResultsMetadata, DomainResultCreationState domainResultCreationState) { - final DomainResultCreationStateImpl creationStateImpl = impl( domainResultCreationState ); + final var creationStateImpl = impl( domainResultCreationState ); creationStateImpl.resolveSqlSelection( ResultsHelper.resolveSqlExpression( creationStateImpl, @@ -316,7 +314,7 @@ private void resolveSqlSelection( SelectableMapping selectableMapping, JdbcValuesMetadata jdbcResultsMetadata, DomainResultCreationState domainResultCreationState) { - final DomainResultCreationStateImpl creationStateImpl = impl( domainResultCreationState ); + final var creationStateImpl = impl( domainResultCreationState ); creationStateImpl.resolveSqlSelection( ResultsHelper.resolveSqlExpression( creationStateImpl, @@ -346,7 +344,7 @@ public DynamicResultBuilderEntityStandard setDiscriminatorAlias(String columnNam @Override public NativeQuery.RootReturn addProperty(String propertyName, String columnAlias) { - final ModelPart subPart = entityMapping.findSubPart( propertyName ); + final var subPart = entityMapping.findSubPart( propertyName ); addProperty( (Fetchable) subPart, columnAlias ); return this; } @@ -377,13 +375,13 @@ public boolean equals(Object o) { return false; } - final DynamicResultBuilderEntityStandard that = (DynamicResultBuilderEntityStandard) o; + final var that = (DynamicResultBuilderEntityStandard) o; return navigablePath.equals( that.navigablePath ) - && entityMapping.equals( that.entityMapping ) - && tableAlias.equals( that.tableAlias ) - && lockMode == that.lockMode - && Objects.equals( idColumnNames, that.idColumnNames ) - && Objects.equals( discriminatorColumnName, that.discriminatorColumnName ) - && super.equals( o ); + && entityMapping.equals( that.entityMapping ) + && tableAlias.equals( that.tableAlias ) + && lockMode == that.lockMode + && Objects.equals( idColumnNames, that.idColumnNames ) + && Objects.equals( discriminatorColumnName, that.discriminatorColumnName ) + && super.equals( o ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderInstantiation.java b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderInstantiation.java index 8c21cd7f4c5b..4285e43a0618 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderInstantiation.java +++ b/hibernate-core/src/main/java/org/hibernate/query/results/internal/dynamic/DynamicResultBuilderInstantiation.java @@ -42,7 +42,7 @@ public boolean equals(Object o) { return false; } - final InstantiationArgument that = (InstantiationArgument) o; + final var that = (InstantiationArgument) o; return argumentBuilder.equals( that.argumentBuilder ) && resultAlias.equals( that.resultAlias ); } @@ -66,7 +66,7 @@ public DynamicResultBuilderInstantiation(JavaType javaType) { private DynamicResultBuilderInstantiation(DynamicResultBuilderInstantiation original) { this.javaType = original.javaType; final List arguments = new ArrayList<>( original.argumentResultBuilders.size() ); - for ( InstantiationArgument arg : original.argumentResultBuilders ) { + for ( var arg : original.argumentResultBuilders ) { arguments.add( new InstantiationArgument( arg.argumentBuilder.cacheKeyInstance(), arg.resultAlias ) ); } this.argumentResultBuilders = arguments; @@ -122,7 +122,7 @@ public boolean equals(Object o) { return false; } - final DynamicResultBuilderInstantiation that = (DynamicResultBuilderInstantiation) o; + final var that = (DynamicResultBuilderInstantiation) o; return javaType.equals( that.javaType ) && argumentResultBuilders.equals( that.argumentResultBuilders ); } diff --git a/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractCommonQueryContract.java b/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractCommonQueryContract.java index 2d80b8dc30cf..e58d63e7b6b6 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractCommonQueryContract.java +++ b/hibernate-core/src/main/java/org/hibernate/query/spi/AbstractCommonQueryContract.java @@ -701,7 +701,7 @@ public QueryParameterImplementor getParameter(int position, Class type private

JavaType

getJavaType(Class

javaType) { return getTypeConfiguration().getJavaTypeRegistry() - .getDescriptor( javaType ); + .resolveDescriptor( javaType ); } protected

QueryParameterBinding

locateBinding(Parameter

parameter) { diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java index 5d5abf49f4ec..711be09f1773 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java @@ -913,7 +913,7 @@ public JpaCompoundSelection tuple(List> selections) { checkMultiselect( selections ); return new SqmJpaCompoundSelection<>( selections.stream().map( selection -> (SqmSelectableNode) selection ).toList(), - getTypeConfiguration().getJavaTypeRegistry().getDescriptor( Tuple.class ), + getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( Tuple.class ), this ); } @@ -973,7 +973,7 @@ public JpaCompoundSelection array(Class resultClass, List JpaCompoundSelection arrayInternal(Class resultClass, List> selections) { checkMultiselect( selections ); - final JavaType javaType = getTypeConfiguration().getJavaTypeRegistry().getDescriptor( resultClass ); + final var javaType = getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( resultClass ); return new SqmJpaCompoundSelection<>( selections, javaType, this ); } @@ -1658,7 +1658,7 @@ class MultiValueParameterType implements SqmBindableType { private final JavaType javaType; public MultiValueParameterType(Class type) { - this.javaType = getTypeConfiguration().getJavaTypeRegistry().getDescriptor( type ); + javaType = getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( type ); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/TypecheckUtil.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/TypecheckUtil.java index 55eee4d12fae..97e86d7ef3a8 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/TypecheckUtil.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/TypecheckUtil.java @@ -26,10 +26,8 @@ import org.hibernate.query.sqm.tree.expression.SqmExpression; import org.hibernate.query.sqm.tree.expression.SqmLiteralNull; import org.hibernate.type.BasicPluralType; -import org.hibernate.type.BasicType; import org.hibernate.type.ConvertedBasicType; import org.hibernate.type.QueryParameterJavaObjectType; -import org.hibernate.type.descriptor.converter.spi.BasicValueConverter; import org.hibernate.type.descriptor.jdbc.JdbcType; import java.time.temporal.Temporal; @@ -135,13 +133,13 @@ public static boolean areTypesComparable( return true; } - final DomainType lhsDomainType = lhsType.getSqmType(); - final DomainType rhsDomainType = rhsType.getSqmType(); + final var lhsDomainType = lhsType.getSqmType(); + final var rhsDomainType = rhsType.getSqmType(); // for embeddables, the embeddable class must match exactly - final EmbeddableDomainType lhsEmbeddable = getEmbeddableType( lhsDomainType ); - final EmbeddableDomainType rhsEmbeddable = getEmbeddableType( rhsDomainType ); + final var lhsEmbeddable = getEmbeddableType( lhsDomainType ); + final var rhsEmbeddable = getEmbeddableType( rhsDomainType ); if ( lhsEmbeddable != null && rhsEmbeddable != null ) { return areEmbeddableTypesComparable( lhsEmbeddable, rhsEmbeddable ); } @@ -209,8 +207,8 @@ private static boolean areJdbcMappingsComparable( } // converters are implicitly applied to the other side when its domain type is compatible else if ( lhsJdbcMapping.getValueConverter() != null || rhsJdbcMapping.getValueConverter() != null ) { - final JdbcMapping lhsDomainMapping = getDomainJdbcType( lhsJdbcMapping, bindingContext); - final JdbcMapping rhsDomainMapping = getDomainJdbcType( rhsJdbcMapping, bindingContext); + final var lhsDomainMapping = getDomainJdbcType( lhsJdbcMapping, bindingContext); + final var rhsDomainMapping = getDomainJdbcType( rhsJdbcMapping, bindingContext); return lhsDomainMapping != null && rhsDomainMapping != null && areJdbcTypesComparable( lhsDomainMapping.getJdbcType(), rhsDomainMapping.getJdbcType() ); } @@ -227,11 +225,11 @@ private static boolean areJdbcTypesComparable(JdbcType lhsJdbcType, JdbcType rhs } private static JdbcMapping getDomainJdbcType(JdbcMapping jdbcMapping, BindingContext bindingContext) { - final BasicValueConverter valueConverter = jdbcMapping.getValueConverter(); + final var valueConverter = jdbcMapping.getValueConverter(); if ( valueConverter != null ) { - final BasicType basicType = + final var basicType = bindingContext.getTypeConfiguration() - .getBasicTypeForJavaType( valueConverter.getDomainJavaType().getJavaType() ); + .getBasicTypeForJavaType( valueConverter.getDomainJavaType().getJavaTypeClass() ); if ( basicType != null ) { return basicType.getJdbcMapping(); } @@ -278,8 +276,8 @@ private static boolean areTupleTypesComparable( private static boolean areEntityTypesComparable( EntityType lhsType, EntityType rhsType, BindingContext bindingContext) { - final EntityPersister lhsEntity = getEntityDescriptor( bindingContext, lhsType.getName() ); - final EntityPersister rhsEntity = getEntityDescriptor( bindingContext, rhsType.getName() ); + final var lhsEntity = getEntityDescriptor( bindingContext, lhsType.getName() ); + final var rhsEntity = getEntityDescriptor( bindingContext, rhsType.getName() ); return lhsEntity.getRootEntityName().equals( rhsEntity.getRootEntityName() ); } @@ -287,19 +285,19 @@ private static boolean isDiscriminatorTypeComparable( EntityDiscriminatorSqmPathSource lhsDiscriminator, DomainType rhsType, BindingContext bindingContext) { final String entityName = lhsDiscriminator.getEntityDomainType().getHibernateEntityName(); - final EntityPersister lhsEntity = bindingContext.getMappingMetamodel().getEntityDescriptor( entityName ); + final var lhsEntity = bindingContext.getMappingMetamodel().getEntityDescriptor( entityName ); if ( rhsType instanceof EntityType entityType ) { final String rhsEntityName = entityType.getName(); - final EntityPersister rhsEntity = getEntityDescriptor( bindingContext, rhsEntityName ); + final var rhsEntity = getEntityDescriptor( bindingContext, rhsEntityName ); return lhsEntity.getRootEntityName().equals( rhsEntity.getRootEntityName() ); } else if ( rhsType instanceof EntityDiscriminatorSqmPathSource discriminator ) { final String rhsEntityName = discriminator.getEntityDomainType().getHibernateEntityName(); - final EntityPersister rhsEntity = bindingContext.getMappingMetamodel().getEntityDescriptor( rhsEntityName ); + final var rhsEntity = bindingContext.getMappingMetamodel().getEntityDescriptor( rhsEntityName ); return rhsEntity.getRootEntityName().equals( lhsEntity.getRootEntityName() ); } else if ( rhsType instanceof SqmBindableType rhsExpressible ) { - final SqmBindableType discriminatorType = (SqmBindableType) + final var discriminatorType = (SqmBindableType) lhsDiscriminator.getEntityMapping().getDiscriminatorMapping().getMappedType(); return areTypesComparable( discriminatorType, rhsExpressible, bindingContext); } @@ -343,11 +341,11 @@ private static boolean isTypeAssignable( // decent approach which allows comparison between literals and enums, // user-defined types, etc. - final DomainType lhsDomainType = targetType.getSqmType(); - final DomainType rhsDomainType = expressionType.getSqmType(); + final var lhsDomainType = targetType.getSqmType(); + final var rhsDomainType = expressionType.getSqmType(); if ( lhsDomainType instanceof JdbcMapping lhsMapping && rhsDomainType instanceof JdbcMapping rhsMapping ) { - final JdbcType lhsJdbcType = lhsMapping.getJdbcType(); - final JdbcType rhsJdbcType = rhsMapping.getJdbcType(); + final var lhsJdbcType = lhsMapping.getJdbcType(); + final var rhsJdbcType = rhsMapping.getJdbcType(); if ( lhsJdbcType.getJdbcTypeCode() == rhsJdbcType.getJdbcTypeCode() // "families" of implicitly-convertible JDBC types // (this list might need to be extended in future) @@ -397,8 +395,8 @@ private static Class canonicalize(Class lhs) { private static boolean isEntityTypeAssignable( EntityType lhsType, EntityType rhsType, BindingContext bindingContext) { - final EntityPersister lhsEntity = getEntityDescriptor( bindingContext, lhsType.getName() ); - final EntityPersister rhsEntity = getEntityDescriptor( bindingContext, rhsType.getName() ); + final var lhsEntity = getEntityDescriptor( bindingContext, lhsType.getName() ); + final var rhsEntity = getEntityDescriptor( bindingContext, rhsType.getName() ); return lhsEntity.isSubclassEntityName( rhsEntity.getEntityName() ); } @@ -411,8 +409,8 @@ private static EntityPersister getEntityDescriptor(BindingContext bindingContext * @see TypecheckUtil#assertAssignable(String, SqmPath, SqmTypedNode, BindingContext) */ public static void assertComparable(Expression x, Expression y, BindingContext bindingContext) { - final SqmExpression left = (SqmExpression) x; - final SqmExpression right = (SqmExpression) y; + final var left = (SqmExpression) x; + final var right = (SqmExpression) y; final Integer leftTupleLength = left.getTupleLength(); final Integer rightTupleLength = right.getTupleLength(); if ( leftTupleLength != null && rightTupleLength != null @@ -428,8 +426,8 @@ public static void assertComparable(Expression x, Expression y, BindingCon // allow comparing literal null to things if ( !( left instanceof SqmLiteralNull ) && !( right instanceof SqmLiteralNull ) ) { - final SqmBindableType leftType = left.getExpressible(); - final SqmBindableType rightType = right.getExpressible(); + final var leftType = left.getExpressible(); + final var rightType = right.getExpressible(); if ( leftType != null && rightType != null && left.isEnum() && right.isEnum() ) { // this is needed by Hibernate Processor due to the weird @@ -466,8 +464,8 @@ public static void assertAssignable( // TODO: check that the target path is nullable } else { - final SqmBindableType targetType = targetPath.getNodeType(); - final SqmBindableType expressionType = expression.getNodeType(); + final var targetType = targetPath.getNodeType(); + final var expressionType = expression.getNodeType(); if ( targetType != null && expressionType != null && targetPath.isEnum() ) { // this is needed by Hibernate Processor due to the weird // handling of enumerated types in the annotation processor @@ -495,11 +493,11 @@ else if ( !isTypeAssignable( targetType, expressionType, bindingContext) ) { } public static void assertOperable(SqmExpression left, SqmExpression right, BinaryArithmeticOperator op) { - final SqmExpressible leftNodeType = left.getExpressible(); - final SqmExpressible rightNodeType = right.getExpressible(); + final var leftNodeType = left.getExpressible(); + final var rightNodeType = right.getExpressible(); if ( leftNodeType != null && rightNodeType != null ) { - final Class leftJavaType = leftNodeType.getRelationalJavaType().getJavaTypeClass(); - final Class rightJavaType = rightNodeType.getRelationalJavaType().getJavaTypeClass(); + final var leftJavaType = leftNodeType.getRelationalJavaType().getJavaTypeClass(); + final var rightJavaType = rightNodeType.getRelationalJavaType().getJavaTypeClass(); if ( Number.class.isAssignableFrom( leftJavaType ) ) { // left operand is a number switch (op) { @@ -596,7 +594,7 @@ else if ( isNumberArray( leftNodeType ) ) { public static boolean isNumberArray(SqmExpressible expressible) { if ( expressible != null ) { - final DomainType domainType = expressible.getSqmType(); + final var domainType = expressible.getSqmType(); if ( domainType != null ) { return domainType instanceof BasicPluralType basicPluralType && Number.class.isAssignableFrom( basicPluralType.getElementType().getJavaType() ); @@ -606,7 +604,7 @@ public static boolean isNumberArray(SqmExpressible expressible) { } public static void assertString(SqmExpression expression) { - final SqmExpressible nodeType = expression.getNodeType(); + final var nodeType = expression.getNodeType(); if ( nodeType != null ) { if ( !( nodeType.getSqmType() instanceof JdbcMapping jdbcMapping ) || !jdbcMapping.getJdbcType().isStringLike() ) { @@ -619,7 +617,7 @@ public static void assertString(SqmExpression expression) { } public static void assertDuration(SqmExpression expression) { - final SqmExpressible nodeType = expression.getNodeType(); + final var nodeType = expression.getNodeType(); if ( nodeType != null ) { if ( !( nodeType.getSqmType() instanceof JdbcMapping jdbcMapping ) || !jdbcMapping.getJdbcType().isDuration() ) { @@ -632,7 +630,7 @@ public static void assertDuration(SqmExpression expression) { } public static void assertNumeric(SqmExpression expression, UnaryArithmeticOperator op) { - final SqmExpressible nodeType = expression.getExpressible(); + final var nodeType = expression.getExpressible(); if ( nodeType != null ) { if ( !( nodeType.getSqmType() instanceof JdbcMapping jdbcMapping ) || !jdbcMapping.getJdbcType().isNumber() ) { diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java index f0fde08661e5..b2bbb999f2fc 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java @@ -1649,7 +1649,7 @@ public SelectStatement visitSelectStatement(SqmSelectStatement statement) { public DynamicInstantiation visitDynamicInstantiation(SqmDynamicInstantiation sqmDynamicInstantiation) { final SqmDynamicInstantiationTarget instantiationTarget = sqmDynamicInstantiation.getInstantiationTarget(); final DynamicInstantiationNature instantiationNature = instantiationTarget.getNature(); - final JavaType targetTypeDescriptor = interpretInstantiationTarget( instantiationTarget ); + final JavaType targetTypeDescriptor = interpretInstantiationTarget( instantiationTarget ); final DynamicInstantiation dynamicInstantiation = new DynamicInstantiation<>( instantiationNature, targetTypeDescriptor ); @@ -1668,10 +1668,8 @@ public DynamicInstantiation visitDynamicInstantiation(SqmDynamicInstantiation return dynamicInstantiation; } - private JavaType interpretInstantiationTarget(SqmDynamicInstantiationTarget instantiationTarget) { - return getCreationContext().getMappingMetamodel() - .getTypeConfiguration() - .getJavaTypeRegistry() + private JavaType interpretInstantiationTarget(SqmDynamicInstantiationTarget instantiationTarget) { + return getCreationContext().getTypeConfiguration().getJavaTypeRegistry() .getDescriptor( switch ( instantiationTarget.getNature() ) { case LIST -> List.class; case MAP -> Map.class; @@ -4767,14 +4765,15 @@ public Object visitMapEntryFunction(SqmMapEntryReference entryRef) { ); registerProjectionUsageFromDescriptor( tableGroup, valueDescriptor ); - return new DomainResultProducer>() { + //noinspection rawtypes + return new DomainResultProducer() { @Override - public DomainResult> createDomainResult( + public DomainResult createDomainResult( String resultVariable, DomainResultCreationState creationState) { - final JavaType> mapEntryDescriptor = getTypeConfiguration() - .getJavaTypeRegistry() - .resolveDescriptor( Map.Entry.class ); + final var mapEntryDescriptor = + getTypeConfiguration().getJavaTypeRegistry() + .resolveDescriptor( Map.Entry.class ); return new SqmMapEntryResult<>( indexResult, valueResult, resultVariable, mapEntryDescriptor ); } diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmUnaryOperation.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmUnaryOperation.java index 6ec55d4ba186..4f7310cc699d 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmUnaryOperation.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmUnaryOperation.java @@ -22,6 +22,7 @@ public SqmUnaryOperation(UnaryArithmeticOperator operation, SqmExpression ope this( operation, operand, + //TODO: this is wrong, T represents the domain type, not the relational type operand.nodeBuilder().getTypeConfiguration().getBasicTypeForJavaType( operand.getExpressible().getRelationalJavaType().getJavaType() ) @@ -55,7 +56,7 @@ public SqmUnaryOperation copy(SqmCopyContext context) { return expression; } - public SqmExpression getOperand() { + public SqmExpression getOperand() { return operand; } diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiation.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiation.java index e88aff875863..99fffdbcc038 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiation.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiation.java @@ -16,7 +16,6 @@ import org.hibernate.query.sqm.NodeBuilder; import org.hibernate.query.sqm.SemanticQueryWalker; import org.hibernate.query.sqm.SqmBindableType; -import org.hibernate.query.sqm.SqmExpressible; import org.hibernate.query.sqm.tree.SqmCopyContext; import org.hibernate.query.sqm.tree.SqmRenderContext; import org.hibernate.query.sqm.tree.domain.SqmDomainType; @@ -62,7 +61,8 @@ public static SqmDynamicInstantiation classInstantiation( NodeBuilder nodeBuilder) { return new SqmDynamicInstantiation<>( new DynamicInstantiationTargetImpl<>( CLASS, - nodeBuilder.getTypeConfiguration().getJavaTypeRegistry().getDescriptor( targetJavaType ) ), + nodeBuilder.getTypeConfiguration().getJavaTypeRegistry() + .resolveDescriptor( targetJavaType ) ), arguments, nodeBuilder ); @@ -81,7 +81,8 @@ public static SqmDynamicInstantiation classInstantiation( List> arguments, NodeBuilder nodeBuilder) { return new SqmDynamicInstantiation<>( new DynamicInstantiationTargetImpl<>( MAP, - nodeBuilder.getTypeConfiguration().getJavaTypeRegistry().getDescriptor( Map.class ) ), + nodeBuilder.getTypeConfiguration().getJavaTypeRegistry() + .getDescriptor( Map.class ) ), arguments, nodeBuilder ); @@ -100,7 +101,8 @@ public static > SqmDynamicInstantiation listInstantiation( List> arguments, NodeBuilder nodeBuilder) { return new SqmDynamicInstantiation<>( new DynamicInstantiationTargetImpl<>( LIST, - nodeBuilder.getTypeConfiguration().getJavaTypeRegistry().getDescriptor( List.class ) ), + nodeBuilder.getTypeConfiguration().getJavaTypeRegistry() + .getDescriptor( List.class ) ), arguments, nodeBuilder ); @@ -122,10 +124,8 @@ private SqmDynamicInstantiation( NodeBuilder nodeBuilder) { super( instantiationTarget.getSqmType(), nodeBuilder ); this.instantiationTarget = instantiationTarget; - for ( SqmSelectableNode argument : arguments ) { - final SqmDynamicInstantiationArgument arg = - new SqmDynamicInstantiationArgument<>( argument, argument.getAlias(), nodeBuilder() ); - addArgument( arg ); + for ( var argument : arguments ) { + addArgument( new SqmDynamicInstantiationArgument<>( argument, argument.getAlias(), nodeBuilder() ) ); } } @@ -146,7 +146,7 @@ public boolean checkInstantiation(TypeConfiguration typeConfiguration) { // where Class objects not available during build return true; } - final List> argTypes = argumentTypes(); + final var argTypes = argumentTypes(); if ( isFullyAliased() ) { final List aliases = getArguments().stream() @@ -168,7 +168,7 @@ public boolean checkInstantiation(TypeConfiguration typeConfiguration) { private List> argumentTypes() { return getArguments().stream() .map( arg -> { - final SqmExpressible expressible = arg.getExpressible(); + final var expressible = arg.getExpressible(); return expressible != null && expressible.getExpressibleJavaType() != null ? expressible.getExpressibleJavaType().getJavaTypeClass() : Void.class; @@ -191,7 +191,7 @@ public SqmDynamicInstantiation copy(SqmCopyContext context) { } else { arguments = new ArrayList<>( this.arguments.size() ); - for ( SqmDynamicInstantiationArgument argument : this.arguments ) { + for ( var argument : this.arguments ) { arguments.add( argument.copy( context ) ); } } @@ -259,8 +259,7 @@ else if ( instantiationTarget.getNature() == MAP ) { @Override public SqmDynamicInstantiationArgument add(SqmExpression expression, String alias) { - final SqmDynamicInstantiationArgument argument = - new SqmDynamicInstantiationArgument<>( expression, alias, nodeBuilder() ); + final var argument = new SqmDynamicInstantiationArgument<>( expression, alias, nodeBuilder() ); addArgument( argument ); return argument; } diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiationTarget.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiationTarget.java index f2ef91888691..58d3aad0d8e6 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiationTarget.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiationTarget.java @@ -33,7 +33,7 @@ public interface SqmDynamicInstantiationTarget extends SqmExpressible { * * @return The type to be instantiated. */ - default Class getJavaType() { + default Class getJavaType() { return getTargetTypeDescriptor().getJavaTypeClass(); } } diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/graph/instantiation/internal/InstantiationHelper.java b/hibernate-core/src/main/java/org/hibernate/sql/results/graph/instantiation/internal/InstantiationHelper.java index 54bc93fd8fa6..730c7ed99ae1 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/graph/instantiation/internal/InstantiationHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/graph/instantiation/internal/InstantiationHelper.java @@ -75,17 +75,16 @@ public static boolean isConstructorCompatible( Constructor constructor, List> argumentTypes, TypeConfiguration typeConfiguration) { - final Type[] genericParameterTypes = constructor.getGenericParameterTypes(); + final var genericParameterTypes = constructor.getGenericParameterTypes(); if ( genericParameterTypes.length == argumentTypes.size() ) { for (int i = 0; i < argumentTypes.size(); i++ ) { final Type parameterType = genericParameterTypes[i]; - final Class argumentType = argumentTypes.get( i ); - final Class type = + final var argumentType = argumentTypes.get( i ); + final var type = parameterType instanceof Class classParameter ? classParameter - : typeConfiguration.getJavaTypeRegistry().resolveDescriptor( parameterType ) + : typeConfiguration.getJavaTypeRegistry().getDescriptor( parameterType ) .getJavaTypeClass(); - if ( !areAssignmentCompatible( type, argumentType ) ) { if ( LOG.isDebugEnabled() ) { LOG.debugf( diff --git a/hibernate-core/src/main/java/org/hibernate/sql/results/spi/ListResultsConsumer.java b/hibernate-core/src/main/java/org/hibernate/sql/results/spi/ListResultsConsumer.java index da07af186bff..76381a11ac27 100644 --- a/hibernate-core/src/main/java/org/hibernate/sql/results/spi/ListResultsConsumer.java +++ b/hibernate-core/src/main/java/org/hibernate/sql/results/spi/ListResultsConsumer.java @@ -303,17 +303,21 @@ private JavaType resolveDomainResultJavaType( if ( resultJavaTypes.size() == 1 ) { final JavaType firstJavaType = resultJavaTypes.get( 0 ); if ( firstJavaType == null ) { - return javaTypeRegistry.resolveDescriptor( Object.class ); + return javaTypeRegistry.getDescriptor( Object.class ); + } + else { + //noinspection unchecked + return (JavaType) firstJavaType; } - //noinspection unchecked - return (JavaType) firstJavaType; } - - return javaTypeRegistry.resolveDescriptor( Object[].class ); + else { + return javaTypeRegistry.getDescriptor( Object[].class ); + } } private static boolean isMoreConcrete(JavaType resultJavaType, @Nullable JavaType javaType) { - return javaType != null && resultJavaType.getJavaTypeClass().isAssignableFrom( javaType.getJavaTypeClass() ); + return javaType != null + && resultJavaType.getJavaTypeClass().isAssignableFrom( javaType.getJavaTypeClass() ); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java index a4052c721995..0032cb2b05a1 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java +++ b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java @@ -67,6 +67,7 @@ private JdbcTypeRegistry getJdbcTypeRegistry() { return typeConfiguration.getJdbcTypeRegistry(); } + @Deprecated(since = "7.2") // due to the unbound type parameter public BasicType getRegisteredType(String key) { var basicType = typesByName.get( key ); if ( basicType == null ) { @@ -91,8 +92,8 @@ else if ( !name.equals( typeReference.getName() ) ) { return createBasicType( name, typeReference ); } - private BasicType createBasicType(String name, BasicTypeReference typeReference) { - final var javaType = getJavaTypeRegistry().getDescriptor( typeReference.getJavaType() ); + private BasicType createBasicType(String name, BasicTypeReference typeReference) { + final var javaType = getJavaTypeRegistry().resolveDescriptor( typeReference.getJavaType() ); final var jdbcType = getJdbcTypeRegistry().getDescriptor( typeReference.getSqlTypeCode() ); final var createdType = createBasicType( typeReference, javaType, jdbcType ); primeRegistryEntry( createdType ); @@ -101,8 +102,8 @@ private BasicType createBasicType(String name, BasicTypeReference typeRefe return createdType; } - private static BasicType createBasicType( - BasicTypeReference typeReference, JavaType javaType, JdbcType jdbcType) { + private static BasicType createBasicType( + BasicTypeReference typeReference, JavaType javaType, JdbcType jdbcType) { final String name = typeReference.getName(); if ( typeReference.getConverter() == null ) { return typeReference.isForceImmutable() @@ -119,6 +120,7 @@ private static BasicType createBasicType( } } + @Deprecated(since = "7.2") // due to the unbound type parameter public BasicType getRegisteredType(java.lang.reflect.Type javaType) { return getRegisteredType( javaType.getTypeName() ); } @@ -257,7 +259,7 @@ private BasicType createIfUnregistered( Supplier> creator) { // Before simply creating the type, we try to find if there is a registered type for this java type, // and if so, if the jdbc type descriptor matches. Unless it does, we at least reuse the name - final BasicType registeredType = getRegisteredType( javaType.getJavaType() ); + final var registeredType = getRegisteredType( javaType.getJavaTypeClass() ); if ( registeredTypeMatches( javaType, jdbcType, registeredType ) ) { return registeredType; } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/AttributeConverterBean.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/AttributeConverterBean.java index ab2100c1a423..fb370f613697 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/AttributeConverterBean.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/AttributeConverterBean.java @@ -12,7 +12,6 @@ import org.hibernate.resource.beans.spi.ManagedBean; import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.java.MutabilityPlan; -import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; import org.hibernate.type.descriptor.java.spi.RegistryHelper; import java.util.Objects; @@ -54,8 +53,8 @@ public AttributeConverterBean( this.attributeConverterBean = attributeConverterBean; this.converterJavaType = converterJavaType; - final JavaTypeRegistry jtdRegistry = context.getJavaTypeRegistry(); - this.jdbcJavaType = jtdRegistry.getDescriptor( jdbcJavaType ); + final var jtdRegistry = context.getJavaTypeRegistry(); + this.jdbcJavaType = jtdRegistry.resolveDescriptor( jdbcJavaType ); this.domainJavaType = jtdRegistry.resolveDescriptor( domainJavaType, () -> getTypeDescriptor( attributeConverterBean, domainJavaType, context ) ); } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/ConverterHelper.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/ConverterHelper.java index f49403fd1f1c..5c2b3ca5d8b0 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/ConverterHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/ConverterHelper.java @@ -10,8 +10,6 @@ import org.hibernate.type.descriptor.converter.spi.JpaAttributeConverter; import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; -import java.lang.reflect.ParameterizedType; -import java.lang.reflect.Type; import static org.hibernate.internal.util.GenericsHelper.extractClass; import static org.hibernate.internal.util.GenericsHelper.extractParameterizedType; @@ -23,30 +21,28 @@ public class ConverterHelper { public static BasicValueConverter createValueConverter( AttributeConverter converter, JavaTypeRegistry registry) { - final ParameterizedType converterType = - extractParameterizedType( converter.getClass(), AttributeConverter.class ); - final Type[] typeArguments = converterType.getActualTypeArguments(); - final Class domainJavaClass = extractClass( typeArguments[0] ); - final Class relationalJavaClass = extractClass( typeArguments[1] ); + final var converterType = extractParameterizedType( converter.getClass(), AttributeConverter.class ); + final var typeArguments = converterType.getActualTypeArguments(); + final var domainJavaClass = extractClass( typeArguments[0] ); + final var relationalJavaClass = extractClass( typeArguments[1] ); return new AttributeConverterInstance<>( converter, - registry.resolveDescriptor( domainJavaClass ), - registry.resolveDescriptor( relationalJavaClass ) + registry.getDescriptor( domainJavaClass ), + registry.getDescriptor( relationalJavaClass ) ); } public static JpaAttributeConverter createJpaAttributeConverter( ManagedBean> bean, JavaTypeRegistry registry) { - final ParameterizedType converterType = - extractParameterizedType( bean.getBeanClass(), AttributeConverter.class ); - final Type[] typeArguments = converterType.getActualTypeArguments(); - final Class domainJavaClass = extractClass( typeArguments[0] ); - final Class relationalJavaClass = extractClass( typeArguments[1] ); + final var converterType = extractParameterizedType( bean.getBeanClass(), AttributeConverter.class ); + final var typeArguments = converterType.getActualTypeArguments(); + final var domainJavaClass = extractClass( typeArguments[0] ); + final var relationalJavaClass = extractClass( typeArguments[1] ); return new AttributeConverterBean<>( bean, registry.resolveDescriptor( bean.getBeanClass() ), - registry.resolveDescriptor( domainJavaClass ), - registry.resolveDescriptor( relationalJavaClass ) + registry.getDescriptor( domainJavaClass ), + registry.getDescriptor( relationalJavaClass ) ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractArrayJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractArrayJavaType.java index e1dc65bddc5d..d7d1207db2bd 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractArrayJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractArrayJavaType.java @@ -101,7 +101,7 @@ BasicType createTypeUsingConverter( final var convertedArrayClass = newInstance( convertedElementClass, 0 ).getClass(); final var relationalJavaType = typeConfiguration.getJavaTypeRegistry() - .getDescriptor( convertedArrayClass ); + .resolveDescriptor( convertedArrayClass ); return new ConvertedBasicArrayType<>( elementType, arrayJdbcType( typeConfiguration, elementType, columnTypeInformation, indicators ), diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java index 30a55024836f..7eba1547090f 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/CollectionJavaType.java @@ -65,7 +65,7 @@ public JavaType createJavaType( case BAG, ID_BAG, LIST, SET, SORTED_SET, ORDERED_SET -> new BasicCollectionJavaType( parameterizedType, - registry.resolveDescriptor( typeArguments[typeArguments.length-1] ), + registry.getDescriptor( typeArguments[typeArguments.length-1] ), semantics ); case MAP, ORDERED_MAP, SORTED_MAP -> @@ -74,8 +74,8 @@ public JavaType createJavaType( parameterizedType, new MapMutabilityPlan( (MapSemantics) semantics, - registry.resolveDescriptor( typeArguments[0] ), - registry.resolveDescriptor( typeArguments[typeArguments.length-1] ) + registry.getDescriptor( typeArguments[0] ), + registry.getDescriptor( typeArguments[typeArguments.length-1] ) ) ); }; diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java index 1fdd8227cee0..43df6c379119 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java @@ -74,10 +74,6 @@ public void forEachDescriptor(Consumer> consumer) { descriptorsByTypeName.values().forEach( consumer ); } - public JavaType getDescriptor(Type javaType) { - return resolveDescriptor( javaType ); - } - public void addDescriptor(JavaType descriptor) { final JavaType old = descriptorsByTypeName.put( descriptor.getJavaType().getTypeName(), descriptor ); if ( old != null ) { @@ -91,11 +87,22 @@ public void addDescriptor(JavaType descriptor) { performInjections( descriptor ); } + @Deprecated(since = "7.2") // Due to unbound type parameter + public JavaType getDescriptor(Type javaType) { + return resolveDescriptor( javaType ); + } + + @Deprecated(since = "7.2") // Due to unbound type parameter public JavaType findDescriptor(Type javaType) { //noinspection unchecked return (JavaType) descriptorsByTypeName.get( javaType.getTypeName() ); } + public JavaType findDescriptor(Class javaType) { + //noinspection unchecked + return (JavaType) descriptorsByTypeName.get( javaType.getTypeName() ); + } + public JavaType resolveDescriptor(Type javaType, Supplier> creator) { return resolveDescriptor( javaType.getTypeName(), creator ); } @@ -112,10 +119,15 @@ private JavaType resolveDescriptor(String javaTypeName, Supplier JavaType resolveDescriptor(Type javaType) { return resolveDescriptor( javaType, JavaTypeRegistry::createMutabilityPlan ); } + public JavaType resolveDescriptor(Class javaType) { + return resolveDescriptor( javaType, JavaTypeRegistry::createMutabilityPlan ); + } + private static MutabilityPlan createMutabilityPlan(Type elementJavaType, TypeConfiguration typeConfiguration) { final MutabilityPlan determinedPlan = RegistryHelper.INSTANCE.determineMutabilityPlan( elementJavaType, diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/jdbc/ArrayJdbcType.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/jdbc/ArrayJdbcType.java index 7a849771dee9..b9dbd5e14d21 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/jdbc/ArrayJdbcType.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/jdbc/ArrayJdbcType.java @@ -66,7 +66,7 @@ public JavaType getJdbcRecommendedJavaTypeMapping( TypeConfiguration typeConfiguration) { final JavaType elementJavaType = elementJdbcType.getJdbcRecommendedJavaTypeMapping( precision, scale, typeConfiguration ); - final JavaType javaType = + final var javaType = typeConfiguration.getJavaTypeRegistry() .resolveDescriptor( newInstance( elementJavaType.getJavaTypeClass(), 0 ).getClass() ); if ( javaType instanceof BasicPluralType ) { diff --git a/hibernate-core/src/main/java/org/hibernate/type/format/jaxb/JaxbXmlFormatMapper.java b/hibernate-core/src/main/java/org/hibernate/type/format/jaxb/JaxbXmlFormatMapper.java index 4aff790faf84..611c39a96420 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/format/jaxb/JaxbXmlFormatMapper.java +++ b/hibernate-core/src/main/java/org/hibernate/type/format/jaxb/JaxbXmlFormatMapper.java @@ -4,7 +4,6 @@ */ package org.hibernate.type.format.jaxb; -import java.io.IOException; import java.io.StringReader; import java.io.StringWriter; import java.lang.reflect.Array; @@ -499,23 +498,11 @@ else if ( javaType.getJavaTypeClass().isArray() ) { } @Override - public boolean supportsSourceType(Class sourceType) { - return false; + public void writeToTarget(T value, JavaType javaType, Object target, WrapperOptions options) { } @Override - public boolean supportsTargetType(Class targetType) { - return false; - } - - @Override - public void writeToTarget(T value, JavaType javaType, Object target, WrapperOptions options) - throws IOException { - - } - - @Override - public T readFromSource(JavaType javaType, Object source, WrapperOptions options) throws IOException { + public T readFromSource(JavaType javaType, Object source, WrapperOptions options) { return null; } @@ -526,7 +513,7 @@ private JAXBElementTransformer createTransformer( Object exampleElement, JAXBIntrospector introspector, WrapperOptions wrapperOptions) { - final JavaType elementJavaType = + final JavaType elementJavaType = wrapperOptions.getTypeConfiguration().getJavaTypeRegistry() .findDescriptor( elementClass ); if ( exampleElement == null && ( elementJavaType == null || JavaTypeHelper.isUnknown( elementJavaType ) ) ) { diff --git a/hibernate-core/src/main/java/org/hibernate/type/internal/BindingTypeHelper.java b/hibernate-core/src/main/java/org/hibernate/type/internal/BindingTypeHelper.java index de32c0a8cada..e99538ad1875 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/internal/BindingTypeHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/type/internal/BindingTypeHelper.java @@ -16,7 +16,6 @@ import org.hibernate.type.BindingContext; import org.hibernate.query.sqm.SqmExpressible; import org.hibernate.type.StandardBasicTypes; -import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.java.JavaTypeHelper; import org.hibernate.type.descriptor.java.TemporalJavaType; import org.hibernate.type.spi.TypeConfiguration; @@ -56,9 +55,9 @@ private static TemporalJavaType getTemporalTypeForPrecision( // since the main purpose of that method is to determine the final java type based on the reflective type // + the explicit @Temporal(TemporalType...) configuration if ( temporalJtd == null || java.util.Date.class.isAssignableFrom( temporalJtd.getJavaTypeClass() ) ) { - final JavaType descriptor = + final var descriptor = typeConfiguration.getJavaTypeRegistry() - .getDescriptor( resolveJavaTypeClass( precision ) ); + .resolveDescriptor( resolveJavaTypeClass( precision ) ); //noinspection unchecked return (TemporalJavaType) descriptor; } diff --git a/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java b/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java index d01624c1ccbe..de087b7f05ac 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java +++ b/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java @@ -367,8 +367,8 @@ public BasicType resolveCastTargetType(String name) { try { final Class javaTypeClass = scope.getClassLoaderService().classForName( name ); - final JavaType jtd = javaTypeRegistry.resolveDescriptor( javaTypeClass ); - final JdbcType jdbcType = jtd.getRecommendedJdbcType( getCurrentBaseSqlTypeIndicators() ); + final var jtd = javaTypeRegistry.resolveDescriptor( javaTypeClass ); + final var jdbcType = jtd.getRecommendedJdbcType( getCurrentBaseSqlTypeIndicators() ); return basicTypeRegistry.resolve( jtd, jdbcType ); } catch ( Exception ignore ) { @@ -763,6 +763,7 @@ public BasicType getBasicTypeForJavaType(Class javaType) { return getBasicTypeForJavaType( (Type) javaType ); } + @Deprecated(since = "7.2") // due to the unbound type parameter public BasicType getBasicTypeForJavaType(Type javaType) { final var existing = basicTypeByJavaType.get( javaType ); if ( existing != null ) { @@ -834,7 +835,7 @@ public BasicType standardBasicTypeForJavaType( } else { // otherwise, apply the creator - return creator.apply( javaTypeRegistry.resolveDescriptor( javaType ) ); + return creator.apply( javaTypeRegistry.getDescriptor( javaType ) ); } } ); diff --git a/hibernate-core/src/main/java/org/hibernate/usertype/UserTypeSupport.java b/hibernate-core/src/main/java/org/hibernate/usertype/UserTypeSupport.java index 6a23f1792bf1..513a91443898 100644 --- a/hibernate-core/src/main/java/org/hibernate/usertype/UserTypeSupport.java +++ b/hibernate-core/src/main/java/org/hibernate/usertype/UserTypeSupport.java @@ -7,7 +7,6 @@ import java.util.function.BiConsumer; import org.hibernate.type.descriptor.java.BasicJavaType; -import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.jdbc.JdbcType; import org.hibernate.type.spi.TypeConfiguration; import org.hibernate.type.spi.TypeConfigurationAware; @@ -29,9 +28,9 @@ public UserTypeSupport(Class returnedClass, int jdbcTypeCode) { @Override protected void resolve(BiConsumer, JdbcType> resolutionConsumer) { assert typeConfiguration != null; - final JavaType descriptor = + final var descriptor = typeConfiguration.getJavaTypeRegistry() - .getDescriptor( returnedClass ); + .resolveDescriptor( returnedClass ); resolutionConsumer.accept( (BasicJavaType) descriptor, typeConfiguration diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/EnumType.java b/hibernate-core/src/test/java/org/hibernate/orm/test/EnumType.java index 07b4254bde1a..338c44fde74f 100644 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/EnumType.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/EnumType.java @@ -21,7 +21,6 @@ import org.hibernate.type.SqlTypes; import org.hibernate.type.descriptor.WrapperOptions; import org.hibernate.type.descriptor.java.EnumJavaType; -import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.jdbc.JdbcType; import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators; import org.hibernate.type.spi.TypeConfiguration; @@ -63,10 +62,6 @@ public class EnumType> public EnumType() { } - public Class getEnumClass() { - return enumClass; - } - /** *

* An instance of this class is "configured" by a call to {@link #setParameterValues}, @@ -105,11 +100,13 @@ public void setParameterValues(Properties parameters) { enumClass = getEnumClass( parameters, reader ); - final JavaType descriptor = typeConfiguration.getJavaTypeRegistry().getDescriptor( enumClass ); - enumJavaType = (EnumJavaType) descriptor; + enumJavaType = + (EnumJavaType) + typeConfiguration.getJavaTypeRegistry() + .resolveDescriptor( enumClass ); if ( parameters.containsKey( TYPE ) ) { - int jdbcTypeCode = Integer.parseInt( (String) parameters.get( TYPE ) ); + final int jdbcTypeCode = Integer.parseInt( (String) parameters.get( TYPE ) ); jdbcType = typeConfiguration.getJdbcTypeRegistry().getDescriptor( jdbcTypeCode ); isOrdinal = jdbcType.isInteger() // Both, ENUM and NAMED_ENUM are treated like ordinal with respect to the ordering @@ -134,7 +131,7 @@ public void setParameterValues(Properties parameters) { columnLength ); } - jdbcType = descriptor.getRecommendedJdbcType( indicators ); + jdbcType = typeConfiguration.getJavaTypeRegistry().resolveDescriptor( enumClass ).getRecommendedJdbcType( indicators ); isOrdinal = indicators.getEnumeratedType() != STRING; } } diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/type/format/XmlFormatterTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/type/format/XmlFormatterTest.java index e23630b73e03..82d68b587630 100644 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/type/format/XmlFormatterTest.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/type/format/XmlFormatterTest.java @@ -202,7 +202,7 @@ private String expectedMapString(Map values) { private String collectionToString(Collection value, Type elementType, FormatMapper formatMapper) { final JavaType javaType = scope.getSessionFactory().getTypeConfiguration().getJavaTypeRegistry() - .resolveDescriptor( new ParameterizedTypeImpl( Collection.class, new Type[] {elementType}, null ) ); + .getDescriptor( new ParameterizedTypeImpl( Collection.class, new Type[] {elementType}, null ) ); final WrapperOptions wrapperOptions = scope.getSessionFactory().getWrapperOptions(); final String actualValue = formatMapper.toString( value, @@ -221,8 +221,9 @@ private String collectionToString(Collection value, Type elementType, FormatM } private String arrayToString(Object value, FormatMapper formatMapper) { - final JavaType javaType = scope.getSessionFactory().getTypeConfiguration().getJavaTypeRegistry() - .resolveDescriptor( value.getClass() ); + final JavaType javaType = + scope.getSessionFactory().getTypeConfiguration().getJavaTypeRegistry() + .getDescriptor( value.getClass() ); final WrapperOptions wrapperOptions = scope.getSessionFactory().getWrapperOptions(); final String actualValue = formatMapper.toString( value, @@ -242,7 +243,7 @@ private String arrayToString(Object value, FormatMapper formatMapper) { private String mapToString(Map value, Type keyType, Type elementType, FormatMapper formatMapper) { final JavaType javaType = scope.getSessionFactory().getTypeConfiguration().getJavaTypeRegistry() - .resolveDescriptor( new ParameterizedTypeImpl( Map.class, new Type[] {keyType, elementType}, null ) ); + .getDescriptor( new ParameterizedTypeImpl( Map.class, new Type[] {keyType, elementType}, null ) ); final WrapperOptions wrapperOptions = scope.getSessionFactory().getWrapperOptions(); final String actualValue = formatMapper.toString( value, diff --git a/hibernate-vector/src/main/java/org/hibernate/vector/internal/HANAVectorJdbcType.java b/hibernate-vector/src/main/java/org/hibernate/vector/internal/HANAVectorJdbcType.java index 4231872b6f25..9c204d91ae71 100644 --- a/hibernate-vector/src/main/java/org/hibernate/vector/internal/HANAVectorJdbcType.java +++ b/hibernate-vector/src/main/java/org/hibernate/vector/internal/HANAVectorJdbcType.java @@ -49,7 +49,7 @@ public JavaType getJdbcRecommendedJavaTypeMapping( Integer precision, Integer scale, TypeConfiguration typeConfiguration) { - return typeConfiguration.getJavaTypeRegistry().resolveDescriptor( float[].class ); + return typeConfiguration.getJavaTypeRegistry().getDescriptor( float[].class ); } @Override diff --git a/hibernate-vector/src/main/java/org/hibernate/vector/internal/MariaDBVectorJdbcType.java b/hibernate-vector/src/main/java/org/hibernate/vector/internal/MariaDBVectorJdbcType.java index b6cd2390f59d..b72cd7538c30 100644 --- a/hibernate-vector/src/main/java/org/hibernate/vector/internal/MariaDBVectorJdbcType.java +++ b/hibernate-vector/src/main/java/org/hibernate/vector/internal/MariaDBVectorJdbcType.java @@ -44,7 +44,7 @@ public JavaType getJdbcRecommendedJavaTypeMapping( Integer precision, Integer scale, TypeConfiguration typeConfiguration) { - return typeConfiguration.getJavaTypeRegistry().resolveDescriptor( float[].class ); + return typeConfiguration.getJavaTypeRegistry().getDescriptor( float[].class ); } @Override diff --git a/hibernate-vector/src/main/java/org/hibernate/vector/internal/MySQLVectorJdbcType.java b/hibernate-vector/src/main/java/org/hibernate/vector/internal/MySQLVectorJdbcType.java index 8c0d6714dfb2..71095bfce147 100644 --- a/hibernate-vector/src/main/java/org/hibernate/vector/internal/MySQLVectorJdbcType.java +++ b/hibernate-vector/src/main/java/org/hibernate/vector/internal/MySQLVectorJdbcType.java @@ -47,7 +47,7 @@ public JavaType getJdbcRecommendedJavaTypeMapping( Integer precision, Integer scale, TypeConfiguration typeConfiguration) { - return typeConfiguration.getJavaTypeRegistry().resolveDescriptor( float[].class ); + return typeConfiguration.getJavaTypeRegistry().getDescriptor( float[].class ); } @Override diff --git a/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGBinaryVectorJdbcType.java b/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGBinaryVectorJdbcType.java index 7969eb8cadb1..6117483fab9c 100644 --- a/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGBinaryVectorJdbcType.java +++ b/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGBinaryVectorJdbcType.java @@ -49,7 +49,7 @@ public JavaType getJdbcRecommendedJavaTypeMapping( Integer precision, Integer scale, TypeConfiguration typeConfiguration) { - return typeConfiguration.getJavaTypeRegistry().resolveDescriptor( byte[].class ); + return typeConfiguration.getJavaTypeRegistry().getDescriptor( byte[].class ); } // @Override diff --git a/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGSparseFloatVectorJdbcType.java b/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGSparseFloatVectorJdbcType.java index 1d64e32cbc43..b7243e1d234f 100644 --- a/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGSparseFloatVectorJdbcType.java +++ b/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGSparseFloatVectorJdbcType.java @@ -43,7 +43,7 @@ public JavaType getJdbcRecommendedJavaTypeMapping( Integer precision, Integer scale, TypeConfiguration typeConfiguration) { - return typeConfiguration.getJavaTypeRegistry().resolveDescriptor( float[].class ); + return typeConfiguration.getJavaTypeRegistry().getDescriptor( float[].class ); } @Override diff --git a/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGVectorJdbcType.java b/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGVectorJdbcType.java index 1118f22c096d..1dc0d917f228 100644 --- a/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGVectorJdbcType.java +++ b/hibernate-vector/src/main/java/org/hibernate/vector/internal/PGVectorJdbcType.java @@ -45,7 +45,7 @@ public JavaType getJdbcRecommendedJavaTypeMapping( Integer precision, Integer scale, TypeConfiguration typeConfiguration) { - return typeConfiguration.getJavaTypeRegistry().resolveDescriptor( float[].class ); + return typeConfiguration.getJavaTypeRegistry().getDescriptor( float[].class ); } @Override diff --git a/hibernate-vector/src/main/java/org/hibernate/vector/internal/SQLServerCastingVectorJdbcType.java b/hibernate-vector/src/main/java/org/hibernate/vector/internal/SQLServerCastingVectorJdbcType.java index 3171f2f8e779..c496ca4a8125 100644 --- a/hibernate-vector/src/main/java/org/hibernate/vector/internal/SQLServerCastingVectorJdbcType.java +++ b/hibernate-vector/src/main/java/org/hibernate/vector/internal/SQLServerCastingVectorJdbcType.java @@ -52,7 +52,7 @@ public JavaType getJdbcRecommendedJavaTypeMapping( Integer precision, Integer scale, TypeConfiguration typeConfiguration) { - return typeConfiguration.getJavaTypeRegistry().resolveDescriptor( float[].class ); + return typeConfiguration.getJavaTypeRegistry().getDescriptor( float[].class ); } @Override diff --git a/tooling/metamodel-generator/src/main/java/org/hibernate/processor/validation/MockSessionFactory.java b/tooling/metamodel-generator/src/main/java/org/hibernate/processor/validation/MockSessionFactory.java index 187aedb60109..afb531d01855 100644 --- a/tooling/metamodel-generator/src/main/java/org/hibernate/processor/validation/MockSessionFactory.java +++ b/tooling/metamodel-generator/src/main/java/org/hibernate/processor/validation/MockSessionFactory.java @@ -891,7 +891,7 @@ public String getTypeName() { public JavaType getJavaConstantType(String className, String fieldName) { return MockSessionFactory.this.getTypeConfiguration() .getJavaTypeRegistry() - .getDescriptor( javaConstantType( className, fieldName ) ); + .resolveDescriptor( javaConstantType( className, fieldName ) ); } @Override @@ -1147,7 +1147,7 @@ private AbstractPluralAttribute createPluralAttribute( property.setName(name); final JavaType collectionJavaType = typeConfiguration.getJavaTypeRegistry() - .getDescriptor(collectionType.getReturnedClass()); + .resolveDescriptor(collectionType.getReturnedClass()); final SqmDomainType elementDomainType = getElementDomainType(entityName, collectionType, owner); final CollectionClassification classification = collectionType.getCollectionClassification(); return switch ( classification ) { From 8215bb17a08abe33ca66e4321987880e1819a7fd Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sat, 6 Sep 2025 16:47:12 +0200 Subject: [PATCH 6/7] slightly clean up handling of arithmetic types in SQM --- .../internal/ConverterDescriptorImpl.java | 3 +- .../hql/internal/SemanticQueryBuilder.java | 2 +- .../sqm/internal/SqmCriteriaNodeBuilder.java | 3 +- .../sqm/sql/BaseSqmToSqlAstConverter.java | 5 ++- .../tree/expression/SqmBinaryArithmetic.java | 22 ++++++----- .../tree/expression/SqmUnaryOperation.java | 23 +++++++---- .../org/hibernate/type/BasicTypeRegistry.java | 1 + .../hibernate/type/spi/TypeConfiguration.java | 38 ++++++++++--------- 8 files changed, 56 insertions(+), 41 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterDescriptorImpl.java b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterDescriptorImpl.java index 273c4cb24d37..3bbfc8d3c8cd 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterDescriptorImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/ConverterDescriptorImpl.java @@ -11,7 +11,6 @@ import org.hibernate.boot.model.convert.spi.JpaAttributeConverterCreationContext; import org.hibernate.type.descriptor.converter.internal.AttributeConverterBean; import org.hibernate.type.descriptor.converter.spi.JpaAttributeConverter; -import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; class ConverterDescriptorImpl implements ConverterDescriptor { @@ -55,7 +54,7 @@ public AutoApplicableConverterDescriptor getAutoApplyDescriptor() { @Override public JpaAttributeConverter createJpaAttributeConverter(JpaAttributeConverterCreationContext context) { - final JavaTypeRegistry javaTypeRegistry = context.getTypeConfiguration().getJavaTypeRegistry(); + final var javaTypeRegistry = context.getTypeConfiguration().getJavaTypeRegistry(); final var converterBean = context.getManagedBeanRegistry().getBean( converterType ); return new AttributeConverterBean<>( converterBean, diff --git a/hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java b/hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java index c8eb578979c6..88a0496ba548 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java +++ b/hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java @@ -3772,7 +3772,7 @@ public SqmUnaryOperation visitUnaryExpression(HqlParser.UnaryExpressionContex final SqmExpression expression = (SqmExpression) ctx.expression().accept(this); final UnaryArithmeticOperator operator = (UnaryArithmeticOperator) ctx.signOperator().accept(this); TypecheckUtil.assertNumeric( expression, operator ); - return new SqmUnaryOperation<>( operator, expression ); + return new SqmUnaryOperation<>( operator, expression, nodeBuilder() ); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java index 711be09f1773..07a41107dbd6 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java @@ -1219,7 +1219,8 @@ public SqmExpression neg(Expression x) { final SqmExpression sqmExpression = (SqmExpression) x; return new SqmUnaryOperation<>( UnaryArithmeticOperator.UNARY_MINUS, - sqmExpression + sqmExpression, + getNodeBuilder() ); } diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java index b2bbb999f2fc..9f39827f9782 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java @@ -107,6 +107,7 @@ import org.hibernate.query.sqm.DiscriminatorSqmPath; import org.hibernate.query.sqm.DynamicInstantiationNature; import org.hibernate.query.sqm.InterpretationException; +import org.hibernate.query.sqm.SqmBindableType; import org.hibernate.query.sqm.SqmExpressible; import org.hibernate.query.sqm.SqmPathSource; import org.hibernate.query.sqm.SqmQuerySource; @@ -5985,8 +5986,8 @@ private MappingModelExpressible determineValueMapping(SqmExpression sqmExp return (MappingModelExpressible) getTypeConfiguration().resolveArithmeticType( // These casts should be safe, since the only JdbcMapping is BasicType // which also implements SqmExpressible - lhs == null ? null : (SqmExpressible) lhs.getSingleJdbcMapping(), - rhs == null ? null : (SqmExpressible) rhs.getSingleJdbcMapping() + lhs == null ? null : (SqmBindableType) lhs.getSingleJdbcMapping(), + rhs == null ? null : (SqmBindableType) rhs.getSingleJdbcMapping() ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmBinaryArithmetic.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmBinaryArithmetic.java index 7b1aa936733e..b46b775d7452 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmBinaryArithmetic.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmBinaryArithmetic.java @@ -33,11 +33,12 @@ public SqmBinaryArithmetic( NodeBuilder nodeBuilder) { //noinspection unchecked super( - (SqmBindableType) nodeBuilder.getTypeConfiguration().resolveArithmeticType( - lhsOperand.getExpressible(), - rhsOperand.getExpressible(), - operator - ), + (SqmBindableType) // TODO: this cast is unsound + nodeBuilder.getTypeConfiguration().resolveArithmeticType( + lhsOperand.getExpressible(), + rhsOperand.getExpressible(), + operator + ), nodeBuilder ); @@ -45,12 +46,15 @@ public SqmBinaryArithmetic( this.operator = operator; this.rhsOperand = rhsOperand; - if ( lhsOperand.getExpressible() == null && isDuration( rhsOperand.getExpressible() ) && - ( operator == ADD || operator == SUBTRACT ) ) { + final SqmBindableType lhsExpressible = lhsOperand.getExpressible(); + final SqmBindableType rhsExpressible = rhsOperand.getExpressible(); + if ( lhsExpressible == null + && isDuration( rhsExpressible ) + && ( operator == ADD || operator == SUBTRACT ) ) { return; } - this.lhsOperand.applyInferableType( rhsOperand.getExpressible() ); - this.rhsOperand.applyInferableType( lhsOperand.getExpressible() ); + this.lhsOperand.applyInferableType( rhsExpressible ); + this.rhsOperand.applyInferableType( lhsExpressible ); } public SqmBinaryArithmetic( diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmUnaryOperation.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmUnaryOperation.java index 4f7310cc699d..a600b96e7f20 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmUnaryOperation.java +++ b/hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/SqmUnaryOperation.java @@ -4,6 +4,7 @@ */ package org.hibernate.query.sqm.tree.expression; +import org.hibernate.query.sqm.NodeBuilder; import org.hibernate.query.sqm.SemanticQueryWalker; import org.hibernate.query.sqm.SqmBindableType; import org.hibernate.query.sqm.UnaryArithmeticOperator; @@ -18,22 +19,27 @@ public class SqmUnaryOperation extends AbstractSqmExpression implements Sq private final UnaryArithmeticOperator operation; private final SqmExpression operand; - public SqmUnaryOperation(UnaryArithmeticOperator operation, SqmExpression operand) { + public SqmUnaryOperation( + UnaryArithmeticOperator operation, + SqmExpression operand, + NodeBuilder nodeBuilder) { + //noinspection unchecked this( operation, operand, - //TODO: this is wrong, T represents the domain type, not the relational type - operand.nodeBuilder().getTypeConfiguration().getBasicTypeForJavaType( - operand.getExpressible().getRelationalJavaType().getJavaType() - ) + (SqmBindableType) // TODO: this cast is unsound + nodeBuilder.getTypeConfiguration() + .resolveArithmeticType( operand.getExpressible() ), + nodeBuilder ); } public SqmUnaryOperation( UnaryArithmeticOperator operation, SqmExpression operand, - SqmBindableType inherentType) { - super( inherentType, operand.nodeBuilder() ); + SqmBindableType inherentType, + NodeBuilder nodeBuilder) { + super( inherentType, nodeBuilder ); this.operation = operation; this.operand = operand; } @@ -49,7 +55,8 @@ public SqmUnaryOperation copy(SqmCopyContext context) { new SqmUnaryOperation<>( operation, operand.copy( context ), - getNodeType() + getNodeType(), + nodeBuilder() ) ); copyTo( expression, context ); diff --git a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java index 0032cb2b05a1..9616978a39ac 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java +++ b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java @@ -141,6 +141,7 @@ public BasicType resolve(Class javaType, int sqlTypeCode) { return resolve( (java.lang.reflect.Type) javaType, sqlTypeCode ); } + @Deprecated(since = "7.2") // due to the unbound type parameter public BasicType resolve(java.lang.reflect.Type javaType, int sqlTypeCode) { return resolve( getJavaTypeRegistry().getDescriptor( javaType ), sqlTypeCode ); } diff --git a/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java b/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java index de087b7f05ac..043b53cd60dd 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java +++ b/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java @@ -684,22 +684,22 @@ public int hashCode() { /** * @see QueryHelper#highestPrecedenceType2 */ - public SqmExpressible resolveArithmeticType( - SqmExpressible firstType, - SqmExpressible secondType, + public SqmBindableType resolveArithmeticType( + SqmBindableType firstType, + SqmBindableType secondType, BinaryArithmeticOperator operator) { return resolveArithmeticType( firstType, secondType ); } /** * Determine the result type of an arithmetic operation as defined by the - * rules in section 6.5.8.1. + * rules in section 6.5.8.1, taking converters into account. * * @see QueryHelper#highestPrecedenceType2 */ - public SqmExpressible resolveArithmeticType( - SqmExpressible firstType, - SqmExpressible secondType) { + public SqmBindableType resolveArithmeticType( + SqmBindableType firstType, + SqmBindableType secondType) { if ( getSqlTemporalType( firstType ) != null ) { if ( secondType==null || getSqlTemporalType( secondType ) != null ) { @@ -731,20 +731,21 @@ else if ( firstType==null && getSqlTemporalType( secondType ) != null ) { } if ( firstType != null && ( secondType == null - || firstType.getRelationalJavaType().isWider( secondType.getRelationalJavaType() ) ) ) { - return resolveBasicArithmeticType( firstType ); + || !secondType.getRelationalJavaType().isWider( firstType.getRelationalJavaType() ) ) ) { + return resolveArithmeticType( firstType ); } - return secondType != null ? resolveBasicArithmeticType( secondType ) : null; + return secondType != null ? resolveArithmeticType( secondType ) : null; } - private BasicType resolveBasicArithmeticType(SqmExpressible expressible) { - if ( isNumberArray( expressible ) ) { - return (BasicType) expressible.getSqmType(); - } - else { - // Use the relational java type to account for possible converters - return getBasicTypeForJavaType( expressible.getRelationalJavaType().getJavaTypeClass() ); - } + /** + * Determine the result type of a unary arithmetic operation, + * taking converters into account. + */ + public SqmBindableType resolveArithmeticType(SqmBindableType expressible) { + return isNumberArray( expressible ) + ? expressible.getSqmType() + // Use the relational java type to account for possible converters + : getBasicTypeForJavaType( expressible.getRelationalJavaType().getJavaTypeClass() ); } private static boolean matchesJavaType(SqmExpressible type, Class javaType) { @@ -797,6 +798,7 @@ public BasicType standardBasicTypeForJavaType(Class javaType) { } } + @Deprecated(since = "7.2") // due to the unbound type parameter public BasicType standardBasicTypeForJavaType(Type javaType) { if ( javaType == null ) { return null; From 576f078a4e4bf9ee8fb95e4050957467018ee153 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sat, 6 Sep 2025 18:24:33 +0200 Subject: [PATCH 7/7] HHH-19757 fix operations with unbound type parameters Many operations of TypeConfiguration, BasicTypeRegistry, JavaTypeRegistry were unsafe due to the use of an unbound type parameter in the return type. Note that this is in principle a breaking change to these SPIs. However, I've done it in a way that minimizes the impact on reasonable code. --- .../boot/model/TypeContributions.java | 6 +- .../internal/AggregateComponentBinder.java | 12 ++- .../metamodel/internal/AttributeFactory.java | 48 ++++++---- .../EmbeddableRepresentationStrategyPojo.java | 6 +- .../metamodel/internal/MetadataContext.java | 21 ++-- .../domain/internal/JpaMetamodelImpl.java | 66 ++++++------- .../FullyQualifiedReflectivePathTerminal.java | 5 +- .../internal/QueryParameterBindingImpl.java | 4 +- .../org/hibernate/type/BasicTypeRegistry.java | 20 ++-- .../internal/AttributeConverterBean.java | 5 +- .../descriptor/java/spi/JavaTypeRegistry.java | 90 +++++++++++------- .../hibernate/type/spi/TypeConfiguration.java | 95 ++++++++++--------- .../usertype/UserTypeLegacyBridge.java | 10 +- .../orm/test/type/BasicTypeRegistryTest.java | 4 +- 14 files changed, 217 insertions(+), 175 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/TypeContributions.java b/hibernate-core/src/main/java/org/hibernate/boot/model/TypeContributions.java index 6a4fd87a536f..494da4e72ba8 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/TypeContributions.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/TypeContributions.java @@ -89,7 +89,7 @@ default void contributeAttributeConverter(Class type) { getTypeConfiguration().getBasicTypeRegistry().register( type ); final JavaType javaType = type.getJavaTypeDescriptor(); - getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( javaType.getJavaType(), () -> javaType ); + getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( javaType ); } /** @@ -99,7 +99,7 @@ default void contributeType(BasicType type) { default void contributeType(BasicType type, String... keys) { getTypeConfiguration().getBasicTypeRegistry().register( type, keys ); final JavaType javaType = type.getJavaTypeDescriptor(); - getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( javaType.getJavaType(), () -> javaType ); + getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( javaType ); } /** @@ -109,6 +109,6 @@ default void contributeType(BasicType type, String... keys) { default void contributeType(UserType type, String... keys) { final CustomType customType = getTypeConfiguration().getBasicTypeRegistry().register( type, keys ); final JavaType javaType = customType.getJavaTypeDescriptor(); - getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( javaType.getJavaType(), () -> javaType ); + getTypeConfiguration().getJavaTypeRegistry().resolveDescriptor( javaType ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AggregateComponentBinder.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AggregateComponentBinder.java index 402966899281..4d9b53cc5f86 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AggregateComponentBinder.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AggregateComponentBinder.java @@ -18,6 +18,7 @@ import org.hibernate.models.spi.MemberDetails; import org.hibernate.type.SqlTypes; import org.hibernate.type.descriptor.java.spi.EmbeddableAggregateJavaType; +import org.hibernate.type.spi.TypeConfiguration; import static org.hibernate.boot.model.internal.BasicValueBinder.Kind.ATTRIBUTE; @@ -45,10 +46,7 @@ public static void processAggregate( final String structName = structQualifiedName == null ? null : structQualifiedName.render(); // We must register a special JavaType for the embeddable which can provide a recommended JdbcType - typeConfiguration.getJavaTypeRegistry().resolveDescriptor( - component.getComponentClass(), - () -> new EmbeddableAggregateJavaType<>( component.getComponentClass(), structName ) - ); + registerDescriptor( component.getComponentClass(), typeConfiguration, structName ); component.setStructName( structQualifiedName ); component.setStructColumnNames( determineStructAttributeNames( inferredData, componentClassDetails ) ); @@ -98,6 +96,12 @@ public static void processAggregate( } } + private static void registerDescriptor(Class componentClass, TypeConfiguration typeConfiguration, String structName) { + typeConfiguration.getJavaTypeRegistry() + .resolveDescriptor( componentClass, + () -> new EmbeddableAggregateJavaType<>( componentClass, structName ) ); + } + private static int getStructPluralSqlTypeCode(MetadataBuildingContext context) { return switch ( context.getPreferredSqlTypeCodeForArray() ) { case SqlTypes.ARRAY -> SqlTypes.STRUCT_ARRAY; diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java index 862a4d6fc7ed..d55de50d6180 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java @@ -29,6 +29,7 @@ import org.hibernate.metamodel.UnsupportedMappingException; import org.hibernate.metamodel.ValueClassification; import org.hibernate.metamodel.mapping.CompositeIdentifierMapping; +import org.hibernate.metamodel.mapping.DiscriminatorType; import org.hibernate.metamodel.mapping.EmbeddableValuedModelPart; import org.hibernate.metamodel.mapping.EntityIdentifierMapping; import org.hibernate.metamodel.model.domain.internal.AbstractIdentifiableType; @@ -237,17 +238,14 @@ private static EmbeddableDomainType classEmbeddableType(MetadataContext conte } final var mappedSuperclass = component.getMappedSuperclass(); - final var superType = mappedSuperclass == null ? null : context.locateMappedSuperclassType( mappedSuperclass ); + final var superType = + mappedSuperclass == null + ? null + : context.locateMappedSuperclassType( mappedSuperclass ); final var discriminatorType = component.isPolymorphic() ? component.getDiscriminatorType() : null; - final var embeddableType = new EmbeddableTypeImpl<>( - context.getJavaTypeRegistry().resolveManagedTypeDescriptor( embeddableClass ), - superType, - discriminatorType, - false, - context.getJpaMetamodel() - ); + final var embeddableType = embeddableType( context, embeddableClass, superType, discriminatorType ); context.registerEmbeddableType( embeddableType, component ); if ( component.isPolymorphic() ) { @@ -259,24 +257,36 @@ private static EmbeddableDomainType classEmbeddableType(MetadataContext conte for ( final String subclassName : embeddableSubclasses ) { if ( domainTypes.containsKey( subclassName ) ) { assert subclassName.equals( embeddableType.getTypeName() ); - continue; } - final Class subclass = classLoaderService.classForName( subclassName ); - final var subType = new EmbeddableTypeImpl<>( - context.getJavaTypeRegistry().resolveManagedTypeDescriptor( subclass ), - domainTypes.get( component.getSuperclass( subclassName ) ), - discriminatorType, - false, - context.getJpaMetamodel() - ); - domainTypes.put( subclassName, subType ); - context.registerEmbeddableType( subType, component ); + else { + final Class subclass = classLoaderService.classForName( subclassName ); + final var superTypeEmbeddable = domainTypes.get( component.getSuperclass( subclassName ) ); + final var subType = embeddableType( context, subclass, superTypeEmbeddable, discriminatorType ); + domainTypes.put( subclassName, subType ); + context.registerEmbeddableType( subType, component ); + } } } return embeddableType; } + private static EmbeddableTypeImpl embeddableType( + MetadataContext context, + Class subclass, + ManagedDomainType superType, + DiscriminatorType discriminatorType) { + @SuppressWarnings("unchecked") + final var castSuperType = (ManagedDomainType) superType; + return new EmbeddableTypeImpl<>( + context.getJavaTypeRegistry().resolveManagedTypeDescriptor( subclass ), + castSuperType, + discriminatorType, + false, + context.getJpaMetamodel() + ); + } + private static EmbeddableTypeImpl dynamicEmbeddableType(MetadataContext context, Component component) { final var embeddableType = new EmbeddableTypeImpl<>( context.getJavaTypeRegistry().resolveDescriptor( java.util.Map.class ), diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyPojo.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyPojo.java index b9c2b2de4e90..1778361bd67f 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyPojo.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/EmbeddableRepresentationStrategyPojo.java @@ -131,10 +131,8 @@ private static JavaType resolveEmbeddableJavaType( return javaTypeRegistry.getDescriptor( bootDescriptor.getComponentClass() ); } else { - return javaTypeRegistry.resolveDescriptor( - compositeUserType.returnedClass(), - () -> new CompositeUserTypeJavaTypeWrapper<>( compositeUserType ) - ); + return javaTypeRegistry.resolveDescriptor( compositeUserType.returnedClass(), + () -> new CompositeUserTypeJavaTypeWrapper<>( compositeUserType ) ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java index f6cda92b5aff..f2e14b8aa72f 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java @@ -577,19 +577,22 @@ private Property getMappedSuperclassIdentifier(PersistentClass persistentClass) return null; } - private EmbeddableTypeImpl applyIdClassMetadata(Component idClassComponent) { - final var embeddableType = - new EmbeddableTypeImpl( - getJavaTypeRegistry().resolveManagedTypeDescriptor( idClassComponent.getComponentClass() ), - getMappedSuperclassDomainType( idClassComponent ), - null, - false, - getJpaMetamodel() - ); + private EmbeddableTypeImpl applyIdClassMetadata(Component idClassComponent) { + final var embeddableType = embeddableType( idClassComponent, idClassComponent.getComponentClass() ); registerEmbeddableType( embeddableType, idClassComponent ); return embeddableType; } + private EmbeddableTypeImpl embeddableType(Component idClassComponent, Class componentClass) { + return new EmbeddableTypeImpl<>( + getJavaTypeRegistry().resolveManagedTypeDescriptor( componentClass ), + getMappedSuperclassDomainType( idClassComponent ), + null, + false, + getJpaMetamodel() + ); + } + @SuppressWarnings("unchecked") private MappedSuperclassDomainType getMappedSuperclassDomainType(Component idClassComponent) { final MappedSuperclass mappedSuperclass = idClassComponent.getMappedSuperclass(); diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java b/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java index 690901e3ddce..47d8ecb9ac17 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java @@ -621,7 +621,7 @@ public void processJpa( ); - for ( PersistentClass entityBinding : bootMetamodel.getEntityBindings() ) { + for ( var entityBinding : bootMetamodel.getEntityBindings() ) { locateOrBuildEntityType( entityBinding, context, typeConfiguration ); } handleUnusedMappedSuperclasses( context, typeConfiguration ); @@ -719,47 +719,47 @@ public static void addAllowedEnumLiteralsToEnumTypesMap( .add( enumClassName ); } - private EntityDomainType locateOrBuildEntityType( + private EntityDomainType locateOrBuildEntityType( PersistentClass persistentClass, MetadataContext context, final TypeConfiguration typeConfiguration) { - @SuppressWarnings("unchecked") - final EntityDomainType entityType = - (EntityDomainType) - context.locateEntityType( persistentClass ); + final var entityType = context.locateEntityType( persistentClass ); return entityType == null ? buildEntityType( persistentClass, context, typeConfiguration ) : entityType; } - private EntityTypeImpl buildEntityType( + private EntityTypeImpl buildEntityType( PersistentClass persistentClass, MetadataContext context, TypeConfiguration typeConfiguration) { context.pushEntityWorkedOn( persistentClass ); - final EntityTypeImpl entityType = - new EntityTypeImpl<>( - javaType( persistentClass, context ), - supertypeForPersistentClass( persistentClass, context, typeConfiguration ), - persistentClass, - this - ); + final var entityType = entityType( persistentClass, persistentClass.getMappedClass(), context, typeConfiguration ); context.registerEntityType( persistentClass, entityType ); context.popEntityWorkedOn( persistentClass ); return entityType; } - @SuppressWarnings("unchecked") - private static JavaType javaType(PersistentClass persistentClass, MetadataContext context) { - final Class javaTypeClass = (Class) persistentClass.getMappedClass(); - if ( javaTypeClass == null || Map.class.isAssignableFrom( javaTypeClass ) ) { + private EntityTypeImpl entityType( + PersistentClass persistentClass, + Class mappedClass, + MetadataContext context, + TypeConfiguration typeConfiguration) { + @SuppressWarnings("unchecked") + final var supertype = + (IdentifiableDomainType) + supertypeForPersistentClass( persistentClass, context, typeConfiguration ); + final JavaType javaType; + if ( mappedClass == null || Map.class.isAssignableFrom( mappedClass ) ) { // dynamic map - return (JavaType) new DynamicModelJavaType(); + //noinspection unchecked + javaType = (JavaType) new DynamicModelJavaType(); } else { - return context.getTypeConfiguration().getJavaTypeRegistry() - .resolveEntityTypeDescriptor( javaTypeClass ); + javaType = context.getTypeConfiguration().getJavaTypeRegistry() + .resolveEntityTypeDescriptor( mappedClass ); } + return new EntityTypeImpl<>( javaType, supertype, persistentClass, this ); } private void handleUnusedMappedSuperclasses(MetadataContext context, TypeConfiguration typeConfiguration) { @@ -772,39 +772,41 @@ private void handleUnusedMappedSuperclasses(MetadataContext context, TypeConfigu } } - private MappedSuperclassDomainType locateOrBuildMappedSuperclassType( + private MappedSuperclassDomainType locateOrBuildMappedSuperclassType( MappedSuperclass mappedSuperclass, MetadataContext context, TypeConfiguration typeConfiguration) { - @SuppressWarnings("unchecked") - final MappedSuperclassDomainType mappedSuperclassType = - (MappedSuperclassDomainType) context.locateMappedSuperclassType( mappedSuperclass ); + final MappedSuperclassDomainType mappedSuperclassType = + context.locateMappedSuperclassType( mappedSuperclass ); return mappedSuperclassType == null - ? buildMappedSuperclassType( mappedSuperclass, context, typeConfiguration ) + ? buildMappedSuperclassType( mappedSuperclass, mappedSuperclass.getMappedClass(), context, typeConfiguration ) : mappedSuperclassType; } private MappedSuperclassTypeImpl buildMappedSuperclassType( MappedSuperclass mappedSuperclass, + Class mappedClass, MetadataContext context, TypeConfiguration typeConfiguration) { + @SuppressWarnings("unchecked") final IdentifiableDomainType superType = - supertypeForMappedSuperclass( mappedSuperclass, context, typeConfiguration ); + (IdentifiableDomainType) + supertypeForMappedSuperclass( mappedSuperclass, context, typeConfiguration ); final JavaType javaType = context.getTypeConfiguration().getJavaTypeRegistry() - .resolveManagedTypeDescriptor( mappedSuperclass.getMappedClass() ); + .resolveManagedTypeDescriptor( mappedClass ); final MappedSuperclassTypeImpl mappedSuperclassType = new MappedSuperclassTypeImpl<>( javaType, mappedSuperclass, superType, this ); context.registerMappedSuperclassType( mappedSuperclass, mappedSuperclassType ); return mappedSuperclassType; } - private IdentifiableDomainType supertypeForPersistentClass( + private IdentifiableDomainType supertypeForPersistentClass( PersistentClass persistentClass, MetadataContext context, TypeConfiguration typeConfiguration) { final MappedSuperclass superMappedSuperclass = persistentClass.getSuperMappedSuperclass(); - final IdentifiableDomainType supertype = + final IdentifiableDomainType supertype = superMappedSuperclass == null ? null : locateOrBuildMappedSuperclassType( superMappedSuperclass, context, typeConfiguration ); @@ -821,12 +823,12 @@ private IdentifiableDomainType supertypeForPersistentClass( } } - private IdentifiableDomainType supertypeForMappedSuperclass( + private IdentifiableDomainType supertypeForMappedSuperclass( MappedSuperclass mappedSuperclass, MetadataContext context, TypeConfiguration typeConfiguration) { final MappedSuperclass superMappedSuperclass = mappedSuperclass.getSuperMappedSuperclass(); - final IdentifiableDomainType superType = + final IdentifiableDomainType superType = superMappedSuperclass == null ? null : locateOrBuildMappedSuperclassType( superMappedSuperclass, context, typeConfiguration ); diff --git a/hibernate-core/src/main/java/org/hibernate/query/hql/internal/FullyQualifiedReflectivePathTerminal.java b/hibernate-core/src/main/java/org/hibernate/query/hql/internal/FullyQualifiedReflectivePathTerminal.java index 53bb22228853..5cef5fab437e 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/hql/internal/FullyQualifiedReflectivePathTerminal.java +++ b/hibernate-core/src/main/java/org/hibernate/query/hql/internal/FullyQualifiedReflectivePathTerminal.java @@ -116,8 +116,9 @@ private SqmExpression createEnumOrFieldLiteral(Class namedClass) throws NoSuchFi if ( namedClass.isEnum() ) { return new SqmEnumLiteral( Enum.valueOf( namedClass, getLocalName() ), - (EnumJavaType) javaTypeRegistry() - .resolveDescriptor( namedClass, () -> new EnumJavaType( namedClass ) ), + (EnumJavaType) + javaTypeRegistry() + .resolveDescriptor( namedClass, () -> new EnumJavaType( namedClass ) ), getLocalName(), nodeBuilder() ); diff --git a/hibernate-core/src/main/java/org/hibernate/query/internal/QueryParameterBindingImpl.java b/hibernate-core/src/main/java/org/hibernate/query/internal/QueryParameterBindingImpl.java index 6a0181416d10..0ec51eacdb43 100644 --- a/hibernate-core/src/main/java/org/hibernate/query/internal/QueryParameterBindingImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/query/internal/QueryParameterBindingImpl.java @@ -134,7 +134,9 @@ private void bindNull(boolean resolveJdbcTypeIfNecessary) { isBound = true; bindValue = null; if ( resolveJdbcTypeIfNecessary && bindType == null ) { - bindType = getTypeConfiguration().getBasicTypeRegistry().getRegisteredType( "null" ); + bindType = (BindableType) + getTypeConfiguration().getBasicTypeRegistry() + .getRegisteredType( "null" ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java index 9616978a39ac..dbfa354a69ff 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java +++ b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java @@ -67,14 +67,12 @@ private JdbcTypeRegistry getJdbcTypeRegistry() { return typeConfiguration.getJdbcTypeRegistry(); } - @Deprecated(since = "7.2") // due to the unbound type parameter - public BasicType getRegisteredType(String key) { + public BasicType getRegisteredType(String key) { var basicType = typesByName.get( key ); if ( basicType == null ) { basicType = resolveTypeReference( key ); } - //noinspection unchecked - return (BasicType) basicType; + return basicType; } private BasicType resolveTypeReference(String name) { @@ -120,13 +118,13 @@ private static BasicType createBasicType( } } - @Deprecated(since = "7.2") // due to the unbound type parameter - public BasicType getRegisteredType(java.lang.reflect.Type javaType) { + public BasicType getRegisteredType(java.lang.reflect.Type javaType) { return getRegisteredType( javaType.getTypeName() ); } public BasicType getRegisteredType(Class javaType) { - return getRegisteredType( javaType.getTypeName() ); + //noinspection unchecked + return (BasicType) getRegisteredType( javaType.getTypeName() ); } public BasicType getRegisteredArrayType(java.lang.reflect.Type javaElementType) { @@ -134,15 +132,15 @@ public BasicType getRegisteredArrayType(java.lang.reflect.Type javaElementTyp } public BasicType resolve(BasicTypeReference basicTypeReference) { - return getRegisteredType( basicTypeReference.getName() ); + //noinspection unchecked + return (BasicType) getRegisteredType( basicTypeReference.getName() ); } public BasicType resolve(Class javaType, int sqlTypeCode) { - return resolve( (java.lang.reflect.Type) javaType, sqlTypeCode ); + return resolve( getJavaTypeRegistry().resolveDescriptor( javaType ), sqlTypeCode ); } - @Deprecated(since = "7.2") // due to the unbound type parameter - public BasicType resolve(java.lang.reflect.Type javaType, int sqlTypeCode) { + public BasicType resolve(java.lang.reflect.Type javaType, int sqlTypeCode) { return resolve( getJavaTypeRegistry().getDescriptor( javaType ), sqlTypeCode ); } diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/AttributeConverterBean.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/AttributeConverterBean.java index fb370f613697..51b9a3fb5909 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/AttributeConverterBean.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/AttributeConverterBean.java @@ -55,8 +55,9 @@ public AttributeConverterBean( final var jtdRegistry = context.getJavaTypeRegistry(); this.jdbcJavaType = jtdRegistry.resolveDescriptor( jdbcJavaType ); - this.domainJavaType = jtdRegistry.resolveDescriptor( domainJavaType, - () -> getTypeDescriptor( attributeConverterBean, domainJavaType, context ) ); + this.domainJavaType = + jtdRegistry.resolveDescriptor( domainJavaType, + () -> getTypeDescriptor( attributeConverterBean, domainJavaType, context ) ); } private JavaType getTypeDescriptor( diff --git a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java index 43df6c379119..d4f9a95dcc22 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java +++ b/hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java @@ -89,47 +89,53 @@ public void addDescriptor(JavaType descriptor) { @Deprecated(since = "7.2") // Due to unbound type parameter public JavaType getDescriptor(Type javaType) { - return resolveDescriptor( javaType ); + //noinspection unchecked + return (JavaType) resolveDescriptor( javaType ); } - @Deprecated(since = "7.2") // Due to unbound type parameter - public JavaType findDescriptor(Type javaType) { - //noinspection unchecked - return (JavaType) descriptorsByTypeName.get( javaType.getTypeName() ); + public JavaType findDescriptor(Type javaType) { + return descriptorsByTypeName.get( javaType.getTypeName() ); } public JavaType findDescriptor(Class javaType) { //noinspection unchecked - return (JavaType) descriptorsByTypeName.get( javaType.getTypeName() ); + return (JavaType) findDescriptor( (Type) javaType ); } - public JavaType resolveDescriptor(Type javaType, Supplier> creator) { - return resolveDescriptor( javaType.getTypeName(), creator ); + public JavaType resolveDescriptor(Class javaType, Supplier> creator) { + //noinspection unchecked + return (JavaType) resolveDescriptor( javaType.getTypeName(), creator ); } - private JavaType resolveDescriptor(String javaTypeName, Supplier> creator) { - final JavaType cached = descriptorsByTypeName.get( javaTypeName ); + @Deprecated(since = "7.2", forRemoval = true) // Can be private + private JavaType resolveDescriptor(String javaTypeName, Supplier> creator) { + final var cached = descriptorsByTypeName.get( javaTypeName ); if ( cached != null ) { - //noinspection unchecked - return (JavaType) cached; + return cached; + } + else { + final var created = creator.get(); + descriptorsByTypeName.put( javaTypeName, created ); + return created; } - - final JavaType created = creator.get(); - descriptorsByTypeName.put( javaTypeName, created ); - return created; } - @Deprecated(since = "7.2") // Due to unbound type parameter - public JavaType resolveDescriptor(Type javaType) { + public JavaType resolveDescriptor(Type javaType) { return resolveDescriptor( javaType, JavaTypeRegistry::createMutabilityPlan ); } public JavaType resolveDescriptor(Class javaType) { - return resolveDescriptor( javaType, JavaTypeRegistry::createMutabilityPlan ); + //noinspection unchecked + return (JavaType) resolveDescriptor( javaType, JavaTypeRegistry::createMutabilityPlan ); } - private static MutabilityPlan createMutabilityPlan(Type elementJavaType, TypeConfiguration typeConfiguration) { - final MutabilityPlan determinedPlan = RegistryHelper.INSTANCE.determineMutabilityPlan( + public JavaType resolveDescriptor(JavaType javaType) { + //noinspection unchecked + return (JavaType) resolveDescriptor( javaType.getJavaTypeClass().getTypeName(), () -> javaType ); + } + + private static MutabilityPlan createMutabilityPlan(Type elementJavaType, TypeConfiguration typeConfiguration) { + final MutabilityPlan determinedPlan = RegistryHelper.INSTANCE.determineMutabilityPlan( elementJavaType, typeConfiguration ); @@ -141,25 +147,27 @@ private static MutabilityPlan createMutabilityPlan(Type elementJavaType, } public JavaType resolveArrayDescriptor(Class elementJavaType) { - return resolveDescriptor( elementJavaType.getTypeName() + "[]", - () -> createArrayTypeDescriptor( elementJavaType, JavaTypeRegistry::createMutabilityPlan) ); + //noinspection unchecked + return (JavaType) + resolveDescriptor( elementJavaType.getTypeName() + "[]", + () -> createArrayTypeDescriptor( elementJavaType, JavaTypeRegistry::createMutabilityPlan) ); } - public JavaType resolveDescriptor( + @Deprecated(since = "7.2", forRemoval = true) // Can be private + public JavaType resolveDescriptor( Type javaType, BiFunction> mutabilityPlanCreator) { return resolveDescriptor( javaType.getTypeName(), () -> { if ( javaType instanceof ParameterizedType parameterizedType ) { - final JavaType rawType = findDescriptor( parameterizedType.getRawType() ); + final var rawType = findDescriptor( parameterizedType.getRawType() ); if ( rawType != null ) { return rawType.createJavaType( parameterizedType, typeConfiguration ); } } else if ( javaType instanceof Class javaClass && javaClass.isArray() ) { - //noinspection unchecked - return (JavaType) createArrayTypeDescriptor( javaClass.getComponentType(), mutabilityPlanCreator ); + return createArrayTypeDescriptor( javaClass.getComponentType(), mutabilityPlanCreator ); } return createTypeDescriptor( javaType, mutabilityPlanCreator ); } @@ -183,25 +191,34 @@ private JavaType createTypeDescriptor(Type javaType, BiFunction JavaType resolveManagedTypeDescriptor(Type javaType) { + public JavaType resolveManagedTypeDescriptor(Type javaType) { return resolveManagedTypeDescriptor( javaType, false ); } - public JavaType resolveEntityTypeDescriptor(Type javaType) { + public JavaType resolveManagedTypeDescriptor(Class javaType) { + //noinspection unchecked + return (JavaType) resolveManagedTypeDescriptor( javaType, false ); + } + + public JavaType resolveEntityTypeDescriptor(Type javaType) { return resolveManagedTypeDescriptor( javaType, true ); } - @SuppressWarnings("unchecked") - private JavaType resolveManagedTypeDescriptor(Type javaType, boolean entity) { + public JavaType resolveEntityTypeDescriptor(Class javaType) { + //noinspection unchecked + return (JavaType) resolveManagedTypeDescriptor( javaType, true ); + } + + private JavaType resolveManagedTypeDescriptor(Type javaType, boolean entity) { return resolveDescriptor( - javaType, + javaType.getTypeName(), () -> { final Class javaTypeClass; if ( javaType instanceof Class ) { javaTypeClass = (Class) javaType; } else { - final ParameterizedType parameterizedType = (ParameterizedType) javaType; + final var parameterizedType = (ParameterizedType) javaType; javaTypeClass = (Class) parameterizedType.getRawType(); } @@ -209,9 +226,10 @@ private JavaType resolveManagedTypeDescriptor(Type javaType, boolean enti javaType, typeConfiguration ); - final MutabilityPlan mutabilityPlan = (determinedPlan != null) - ? determinedPlan - : (MutabilityPlan) MutableMutabilityPlan.INSTANCE; + final MutabilityPlan mutabilityPlan = + determinedPlan != null + ? determinedPlan + : (MutabilityPlan) MutableMutabilityPlan.INSTANCE; return entity ? new EntityJavaType<>( javaTypeClass, mutabilityPlan ) diff --git a/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java b/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java index 043b53cd60dd..e7e43c305b72 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java +++ b/hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java @@ -286,23 +286,25 @@ public void sessionFactoryClosed(SessionFactory factory) { public void addBasicTypeRegistrationContributions(List contributions) { for ( var basicTypeRegistration : contributions ) { - final var basicType = basicTypeRegistration.getBasicType(); + addBasicTypeRegistration( basicTypeRegistration, basicTypeRegistration.getBasicType() ); + } + } - basicTypeRegistry.register( - basicType, - basicTypeRegistration.getRegistrationKeys() - ); + private void addBasicTypeRegistration(BasicTypeRegistration basicTypeRegistration, BasicType basicType) { + basicTypeRegistry.register( + basicType, + basicTypeRegistration.getRegistrationKeys() + ); - javaTypeRegistry.resolveDescriptor( - basicType.getJavaType(), - basicType::getJavaTypeDescriptor - ); + javaTypeRegistry.resolveDescriptor( + basicType.getJavaType(), + basicType::getJavaTypeDescriptor + ); - jdbcToHibernateTypeContributionMap.computeIfAbsent( + jdbcToHibernateTypeContributionMap.computeIfAbsent( basicType.getJdbcType().getDefaultSqlTypeCode(), k -> new HashSet<>() - ).add( basicType.getName() ); - } + ).add( basicType.getName() ); } /** @@ -757,22 +759,22 @@ private static boolean matchesJavaType(SqmExpressible type, Class javaType private final ConcurrentHashMap> basicTypeByJavaType = new ConcurrentHashMap<>(); public BasicType getBasicTypeForGenericJavaType(Class javaType, Type... typeArguments) { - return getBasicTypeForJavaType( new ParameterizedTypeImpl( javaType, typeArguments, null ) ); + //noinspection unchecked + return (BasicType) getBasicTypeForJavaType( new ParameterizedTypeImpl( javaType, typeArguments, null ) ); } public BasicType getBasicTypeForJavaType(Class javaType) { - return getBasicTypeForJavaType( (Type) javaType ); + //noinspection unchecked + return (BasicType) getBasicTypeForJavaType( (Type) javaType ); } - @Deprecated(since = "7.2") // due to the unbound type parameter - public BasicType getBasicTypeForJavaType(Type javaType) { + public BasicType getBasicTypeForJavaType(Type javaType) { final var existing = basicTypeByJavaType.get( javaType ); if ( existing != null ) { - //noinspection unchecked - return (BasicType) existing; + return existing; } else { - final BasicType registeredType = basicTypeRegistry.getRegisteredType( javaType ); + final var registeredType = basicTypeRegistry.getRegisteredType( javaType ); if ( registeredType != null ) { basicTypeByJavaType.put( javaType, registeredType ); return registeredType; @@ -788,57 +790,58 @@ public BasicType standardBasicTypeForJavaType(Class javaType) { return null; } else { - return standardBasicTypeForJavaType( - javaType, - javaTypeDescriptor -> new BasicTypeImpl<>( - javaTypeDescriptor, - javaTypeDescriptor.getRecommendedJdbcType( getCurrentBaseSqlTypeIndicators() ) - ) - ); + return standardBasicTypeForJavaType( javaType, + javaTypeDescriptor -> new BasicTypeImpl<>( javaTypeDescriptor, + javaTypeDescriptor.getRecommendedJdbcType( getCurrentBaseSqlTypeIndicators() ) ) ); } } - @Deprecated(since = "7.2") // due to the unbound type parameter public BasicType standardBasicTypeForJavaType(Type javaType) { if ( javaType == null ) { return null; } else { - return standardBasicTypeForJavaType( - javaType, - javaTypeDescriptor -> new BasicTypeImpl<>( - javaTypeDescriptor, - javaTypeDescriptor.getRecommendedJdbcType( getCurrentBaseSqlTypeIndicators() ) - ) - ); + return standardBasicTypeForJavaType( javaType, + javaTypeDescriptor -> new BasicTypeImpl<>( javaTypeDescriptor, + javaTypeDescriptor.getRecommendedJdbcType( getCurrentBaseSqlTypeIndicators() ) ) ); } } + @Deprecated(since = "7.2", forRemoval = true) // Can be private public BasicType standardBasicTypeForJavaType( Class javaType, Function, BasicType> creator) { - return standardBasicTypeForJavaType( (Type) javaType, creator ); + if ( javaType == null ) { + return null; + } + //noinspection unchecked + return (BasicType) basicTypeByJavaType.computeIfAbsent( + javaType, + jt -> { + // See if one exists in the BasicTypeRegistry and use that one if so + final var registeredType = basicTypeRegistry.getRegisteredType( javaType ); + return registeredType != null + ? registeredType + : creator.apply( javaTypeRegistry.getDescriptor( javaType ) ); + } + ); } - public BasicType standardBasicTypeForJavaType( + @Deprecated(since = "7.2", forRemoval = true) // Due to weird signature + public BasicType standardBasicTypeForJavaType( Type javaType, Function, BasicType> creator) { if ( javaType == null ) { return null; } - //noinspection unchecked - return (BasicType) basicTypeByJavaType.computeIfAbsent( + return basicTypeByJavaType.computeIfAbsent( javaType, jt -> { // See if one exists in the BasicTypeRegistry and use that one if so - final BasicType registeredType = basicTypeRegistry.getRegisteredType( javaType ); - if ( registeredType != null ) { - return registeredType; - } - else { - // otherwise, apply the creator - return creator.apply( javaTypeRegistry.getDescriptor( javaType ) ); - } + final var registeredType = basicTypeRegistry.getRegisteredType( javaType ); + return registeredType != null + ? registeredType + : creator.apply( javaTypeRegistry.getDescriptor( javaType ) ); } ); } diff --git a/hibernate-core/src/main/java/org/hibernate/usertype/UserTypeLegacyBridge.java b/hibernate-core/src/main/java/org/hibernate/usertype/UserTypeLegacyBridge.java index 3ac0c36bd8bf..df56485665c7 100644 --- a/hibernate-core/src/main/java/org/hibernate/usertype/UserTypeLegacyBridge.java +++ b/hibernate-core/src/main/java/org/hibernate/usertype/UserTypeLegacyBridge.java @@ -21,7 +21,9 @@ * * @see Type */ -public class UserTypeLegacyBridge extends BaseUserTypeSupport implements ParameterizedType, TypeConfigurationAware { +public class UserTypeLegacyBridge + extends BaseUserTypeSupport + implements ParameterizedType, TypeConfigurationAware { public static final String TYPE_NAME_PARAM_KEY = "hbm-type-name"; private TypeConfiguration typeConfiguration; @@ -59,13 +61,13 @@ public void setParameterValues(Properties parameters) { protected void resolve(BiConsumer, JdbcType> resolutionConsumer) { assert typeConfiguration != null; - final BasicType registeredType = + final var registeredType = + (BasicType) typeConfiguration.getBasicTypeRegistry() .getRegisteredType( hbmStyleTypeName ); resolutionConsumer.accept( - (BasicJavaType) - registeredType.getJavaTypeDescriptor(), + (BasicJavaType) registeredType.getJavaTypeDescriptor(), registeredType.getJdbcType() ); } diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/type/BasicTypeRegistryTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/type/BasicTypeRegistryTest.java index efa5468106ad..bcd6bce57aa8 100644 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/type/BasicTypeRegistryTest.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/type/BasicTypeRegistryTest.java @@ -51,14 +51,14 @@ public void testOverriding() { assertTrue( uuidBinaryRegistration.getJavaTypeDescriptor() instanceof UUIDJavaType ); assertTrue( uuidBinaryRegistration.getJdbcType() instanceof BinaryJdbcType ); - final BasicType uuidRegistration = registry.getRegisteredType( UUID.class.getName() ); + final BasicType uuidRegistration = registry.getRegisteredType( UUID.class.getName() ); assertTrue( uuidRegistration.getJavaTypeDescriptor() instanceof UUIDJavaType ); assertTrue( uuidRegistration.getJdbcType() instanceof ObjectJdbcType ); final BasicType override = new BasicTypeImpl<>( UUIDJavaType.INSTANCE, CharJdbcType.INSTANCE ); registry.register( override, UUID.class.getName() ); - final BasicType overrideRegistration = registry.getRegisteredType( UUID.class.getName() ); + final BasicType overrideRegistration = registry.getRegisteredType( UUID.class.getName() ); assertSame( override, overrideRegistration ); assertNotSame( uuidBinaryRegistration, overrideRegistration );