diff --git a/hibernate-core/src/main/java/org/hibernate/cfg/MultiTenancySettings.java b/hibernate-core/src/main/java/org/hibernate/cfg/MultiTenancySettings.java index 70e4a16d21ab..60a6b36684ec 100644 --- a/hibernate-core/src/main/java/org/hibernate/cfg/MultiTenancySettings.java +++ b/hibernate-core/src/main/java/org/hibernate/cfg/MultiTenancySettings.java @@ -13,8 +13,14 @@ public interface MultiTenancySettings { /** - * Specifies a {@link MultiTenantConnectionProvider} - * to use. Since {@code MultiTenantConnectionProvider} is also a service, it may be configured + * Specifies a {@link MultiTenantConnectionProvider} to use, either: + * + * + * Since {@code MultiTenantConnectionProvider} is also a service, it may be configured * directly via the {@link org.hibernate.boot.registry.StandardServiceRegistryBuilder}. * * @since 4.1 diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/ConnectionProviderInitiator.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/ConnectionProviderInitiator.java index 4d9fb06c5fbd..5c355ed2b989 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/ConnectionProviderInitiator.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/ConnectionProviderInitiator.java @@ -6,7 +6,6 @@ import java.lang.reflect.InvocationTargetException; import java.sql.Connection; -import java.util.Collection; import java.util.HashSet; import java.util.Map; import java.util.Properties; @@ -24,6 +23,7 @@ import org.hibernate.resource.beans.internal.Helper; import org.hibernate.service.spi.ServiceRegistryImplementor; +import static java.lang.Integer.parseInt; import static java.sql.Connection.TRANSACTION_NONE; import static java.sql.Connection.TRANSACTION_READ_COMMITTED; import static java.sql.Connection.TRANSACTION_READ_UNCOMMITTED; @@ -90,8 +90,8 @@ public ConnectionProvider initiateService( return null; } - final BeanContainer beanContainer = Helper.getBeanContainer( registry ); - final StrategySelector strategySelector = registry.requireService( StrategySelector.class ); + final var beanContainer = Helper.getBeanContainer( registry ); + final var strategySelector = registry.requireService( StrategySelector.class ); final Object explicitSetting = configurationValues.get( CONNECTION_PROVIDER ); if ( explicitSetting != null ) { // if we are explicitly supplied a ConnectionProvider to use (in some form) -> use it.. @@ -118,17 +118,15 @@ private static Class connectionProviderClass(Class throw new ConnectionProviderConfigurationException( "Class '" + providerClass.getName() + "' does not implement 'ConnectionProvider'" ); } - @SuppressWarnings("unchecked") - final Class connectionProviderClass = - (Class) providerClass; + @SuppressWarnings("unchecked") // Safe, we just checked + final var connectionProviderClass = (Class) providerClass; return connectionProviderClass; } private ConnectionProvider instantiateNamedConnectionProvider( String providerName, StrategySelector strategySelector, BeanContainer beanContainer) { LOG.instantiatingExplicitConnectionProvider( providerName ); - final Class providerClass = - strategySelector.selectStrategyImplementor( ConnectionProvider.class, providerName ); + final var providerClass = strategySelector.selectStrategyImplementor( ConnectionProvider.class, providerName ); try { return instantiateExplicitConnectionProvider( providerClass, beanContainer ); } @@ -143,8 +141,7 @@ private ConnectionProvider instantiateConnectionProvider( return new DataSourceConnectionProvider(); } - final Class singleRegisteredProvider = - getSingleRegisteredProvider( strategySelector ); + final var singleRegisteredProvider = getSingleRegisteredProvider( strategySelector ); if ( singleRegisteredProvider != null ) { try { return singleRegisteredProvider.getConstructor().newInstance(); @@ -188,8 +185,7 @@ private ConnectionProvider noAppropriateConnectionProvider() { } private Class getSingleRegisteredProvider(StrategySelector strategySelector) { - final Collection> implementors = - strategySelector.getRegisteredStrategyImplementors( ConnectionProvider.class ); + final var implementors = strategySelector.getRegisteredStrategyImplementors( ConnectionProvider.class ); return implementors != null && implementors.size() == 1 ? implementors.iterator().next() : null; @@ -245,7 +241,7 @@ private static ConnectionProvider instantiateProvider(StrategySelector selector, * @return The connection properties. */ public static Properties getConnectionProperties(Map properties) { - final Properties result = new Properties(); + final var result = new Properties(); for ( var entry : properties.entrySet() ) { if ( entry.getValue() instanceof String value ) { final String key = entry.getKey(); @@ -343,7 +339,7 @@ else if ( ISOLATION_VALUE_MAP.containsKey( string ) ) { else { // it could be a String representation of the isolation numeric value try { - final int isolationLevel = Integer.parseInt( string ); + final int isolationLevel = parseInt( string ); checkIsolationLevel( isolationLevel ); return isolationLevel; } @@ -397,8 +393,8 @@ public static String toIsolationNiceName(Integer isolation) { public static String extractSetting(Map settings, String... names) { for ( String name : names ) { - if ( settings.containsKey(name) ) { - return (String) settings.get(name); + if ( settings.containsKey( name ) ) { + return (String) settings.get( name ); } } return null; diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/MultiTenantConnectionProviderInitiator.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/MultiTenantConnectionProviderInitiator.java index d0b194aa2fc3..e3dd902d7b27 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/MultiTenantConnectionProviderInitiator.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/internal/MultiTenantConnectionProviderInitiator.java @@ -9,14 +9,15 @@ import org.hibernate.boot.registry.StandardServiceInitiator; import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; import org.hibernate.boot.registry.classloading.spi.ClassLoadingException; -import org.hibernate.cfg.AvailableSettings; +import org.hibernate.cfg.JdbcSettings; +import org.hibernate.engine.jdbc.connections.spi.ConnectionProviderConfigurationException; import org.hibernate.engine.jdbc.connections.spi.DataSourceBasedMultiTenantConnectionProviderImpl; import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider; import org.hibernate.resource.beans.internal.Helper; import org.hibernate.service.spi.ServiceException; import org.hibernate.service.spi.ServiceRegistryImplementor; -import org.jboss.logging.Logger; +import static org.hibernate.cfg.MultiTenancySettings.MULTI_TENANT_CONNECTION_PROVIDER; /** * A service initiator for the {@link MultiTenantConnectionProvider} service. @@ -24,7 +25,6 @@ * @author Steve Ebersole */ public class MultiTenantConnectionProviderInitiator implements StandardServiceInitiator> { - private static final Logger log = Logger.getLogger( MultiTenantConnectionProviderInitiator.class ); /** * Singleton access @@ -39,7 +39,7 @@ public Class> getServiceInitiated() { @Override public MultiTenantConnectionProvider initiateService(Map configurationValues, ServiceRegistryImplementor registry) { - if ( !configurationValues.containsKey( AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER ) ) { + if ( !configurationValues.containsKey( MULTI_TENANT_CONNECTION_PROVIDER ) ) { return Helper.getBean( Helper.getBeanContainer( registry ), MultiTenantConnectionProvider.class, @@ -49,46 +49,48 @@ public MultiTenantConnectionProvider initiateService(Map conf ); } - final Object configValue = configurationValues.get( AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER ); + final Object configValue = configurationValues.get( MULTI_TENANT_CONNECTION_PROVIDER ); if ( configValue == null ) { - // if they also specified the data source *name*, then lets assume they want + // if they also specified the data source *name*, then let's assume they want // DataSourceBasedMultiTenantConnectionProviderImpl - final Object dataSourceConfigValue = configurationValues.get( AvailableSettings.DATASOURCE ); - if ( dataSourceConfigValue instanceof String ) { - return new DataSourceBasedMultiTenantConnectionProviderImpl<>(); - } - - return null; + final Object dataSourceConfigValue = configurationValues.get( JdbcSettings.DATASOURCE ); + return dataSourceConfigValue instanceof String + ? new DataSourceBasedMultiTenantConnectionProviderImpl<>() + : null; } - - if ( configValue instanceof MultiTenantConnectionProvider multiTenantConnectionProvider ) { + else if ( configValue instanceof MultiTenantConnectionProvider multiTenantConnectionProvider ) { return multiTenantConnectionProvider; } else { - final Class> implClass; - if ( configValue instanceof Class ) { - @SuppressWarnings("unchecked") - Class> clazz = (Class>) configValue; - implClass = clazz; + final var providerClass = providerClass( registry, configValue ); + try { + return providerClass.newInstance(); } - else { - final String className = configValue.toString(); - final ClassLoaderService classLoaderService = registry.requireService( ClassLoaderService.class ); - try { - implClass = classLoaderService.classForName( className ); - } - catch (ClassLoadingException cle) { - log.warn( "Unable to locate specified class [" + className + "]", cle ); - throw new ServiceException( "Unable to locate specified multi-tenant connection provider [" + className + "]" ); - } + catch (Exception e) { + throw new ServiceException( "Unable to instantiate specified multi-tenant connection provider [" + providerClass.getName() + "]", e ); } + } + } + private static Class> providerClass( + ServiceRegistryImplementor registry, Object configValue) { + if ( configValue instanceof Class configType ) { + if ( !MultiTenantConnectionProvider.class.isAssignableFrom( configType ) ) { + throw new ConnectionProviderConfigurationException( "Class '" + configType.getName() + + "' does not implement 'MultiTenantConnectionProvider'" ); + } + @SuppressWarnings("unchecked") // Safe, we just checked + final var providerClass = (Class>) configType; + return providerClass; + } + else { + final String className = configValue.toString(); + final var classLoaderService = registry.requireService( ClassLoaderService.class ); try { - return implClass.newInstance(); + return classLoaderService.classForName( className ); } - catch (Exception e) { - log.warn( "Unable to instantiate specified class [" + implClass.getName() + "]", e ); - throw new ServiceException( "Unable to instantiate specified multi-tenant connection provider [" + implClass.getName() + "]" ); + catch (ClassLoadingException cle) { + throw new ServiceException( "Unable to locate specified multi-tenant connection provider [" + className + "]", cle ); } } } 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 3ce06f230a0f..9f9a881aed7d 100644 --- a/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java +++ b/hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java @@ -12,16 +12,16 @@ import org.hibernate.HibernateException; import org.hibernate.Internal; import org.hibernate.MappingException; +import org.hibernate.boot.spi.BootstrapContext; import org.hibernate.internal.CoreLogging; import org.hibernate.internal.CoreMessageLogger; -import org.hibernate.internal.util.StringHelper; -import org.hibernate.internal.util.collections.CollectionHelper; -import org.hibernate.type.descriptor.converter.spi.BasicValueConverter; import org.hibernate.type.descriptor.java.BasicPluralJavaType; import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan; import org.hibernate.type.descriptor.java.JavaType; +import org.hibernate.type.descriptor.java.spi.JavaTypeRegistry; import org.hibernate.type.descriptor.jdbc.ArrayJdbcType; import org.hibernate.type.descriptor.jdbc.JdbcType; +import org.hibernate.type.descriptor.jdbc.spi.JdbcTypeRegistry; import org.hibernate.type.internal.BasicTypeImpl; import org.hibernate.type.internal.ConvertedBasicTypeImpl; import org.hibernate.type.internal.CustomMutabilityConvertedBasicTypeImpl; @@ -30,6 +30,9 @@ import org.hibernate.type.spi.TypeConfiguration; import org.hibernate.usertype.UserType; +import static org.hibernate.internal.util.StringHelper.isNotEmpty; +import static org.hibernate.internal.util.collections.CollectionHelper.isEmpty; + /** * A registry of {@link BasicType} instances * @@ -53,8 +56,16 @@ public BasicTypeRegistry(TypeConfiguration typeConfiguration){ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Access + private JavaTypeRegistry getJavaTypeRegistry() { + return typeConfiguration.getJavaTypeRegistry(); + } + + private JdbcTypeRegistry getJdbcTypeRegistry() { + return typeConfiguration.getJdbcTypeRegistry(); + } + public BasicType getRegisteredType(String key) { - BasicType basicType = typesByName.get( key ); + var basicType = typesByName.get( key ); if ( basicType == null ) { basicType = resolveTypeReference( key ); } @@ -63,12 +74,12 @@ public BasicType getRegisteredType(String key) { } private BasicType resolveTypeReference(String name) { - final BasicTypeReference typeReference = typeReferencesByName.get( name ); + final var typeReference = typeReferencesByName.get( name ); if ( typeReference == null ) { return null; } else if ( !name.equals( typeReference.getName() ) ) { - final BasicType basicType = typesByName.get( typeReference.getName() ); + final var basicType = typesByName.get( typeReference.getName() ); if ( basicType != null ) { return basicType; } @@ -78,13 +89,9 @@ else if ( !name.equals( typeReference.getName() ) ) { } private BasicType createBasicType(String name, BasicTypeReference typeReference) { - final JavaType javaType = - typeConfiguration.getJavaTypeRegistry() - .getDescriptor( typeReference.getJavaType() ); - final JdbcType jdbcType = - typeConfiguration.getJdbcTypeRegistry() - .getDescriptor( typeReference.getSqlTypeCode() ); - final BasicType createdType = createBasicType( typeReference, javaType, jdbcType ); + final var javaType = getJavaTypeRegistry().getDescriptor( typeReference.getJavaType() ); + final var jdbcType = getJdbcTypeRegistry().getDescriptor( typeReference.getSqlTypeCode() ); + final var createdType = createBasicType( typeReference, javaType, jdbcType ); primeRegistryEntry( createdType ); typesByName.put( typeReference.getName(), createdType ); typesByName.put( name, createdType ); @@ -100,7 +107,7 @@ private static BasicType createBasicType( : new NamedBasicTypeImpl<>( javaType, jdbcType, name ); } else { - final BasicValueConverter converter = typeReference.getConverter(); + final var converter = typeReference.getConverter(); assert javaType == converter.getDomainJavaType(); return typeReference.isForceImmutable() ? new CustomMutabilityConvertedBasicTypeImpl<>( name, jdbcType, converter, @@ -130,11 +137,11 @@ public BasicType resolve(Class javaType, int sqlTypeCode) { } public BasicType resolve(java.lang.reflect.Type javaType, int sqlTypeCode) { - return resolve( typeConfiguration.getJavaTypeRegistry().getDescriptor( javaType ), sqlTypeCode ); + return resolve( getJavaTypeRegistry().getDescriptor( javaType ), sqlTypeCode ); } public BasicType resolve(JavaType javaType, int sqlTypeCode) { - return resolve( javaType, typeConfiguration.getJdbcTypeRegistry().getDescriptor( sqlTypeCode ) ); + return resolve( javaType, getJdbcTypeRegistry().getDescriptor( sqlTypeCode ) ); } /** @@ -142,11 +149,7 @@ public BasicType resolve(JavaType javaType, int sqlTypeCode) { * descriptor and {@link JdbcType} descriptor combo or create (and register) one. */ public BasicType resolve(JavaType javaType, JdbcType jdbcType) { - return resolve( - javaType, - jdbcType, - () -> resolvedType( javaType, jdbcType ) - ); + return resolve( javaType, jdbcType, () -> resolvedType( javaType, jdbcType ) ); } private BasicType resolvedType(JavaType javaType, JdbcType jdbcType) { @@ -161,20 +164,20 @@ private BasicType resolvedType(JavaType javaType, JdbcType jdbcType) { } private BasicType resolvedType(ArrayJdbcType arrayType, BasicPluralJavaType castPluralJavaType) { - final BasicType elementType = resolve( castPluralJavaType.getElementJavaType(), arrayType.getElementJdbcType() ); - final BasicType resolvedType = castPluralJavaType.resolveType( + final var elementType = resolve( castPluralJavaType.getElementJavaType(), arrayType.getElementJdbcType() ); + final var indicators = typeConfiguration.getCurrentBaseSqlTypeIndicators(); + final var resolvedType = castPluralJavaType.resolveType( typeConfiguration, - typeConfiguration.getCurrentBaseSqlTypeIndicators().getDialect(), + indicators.getDialect(), elementType, null, - typeConfiguration.getCurrentBaseSqlTypeIndicators() + indicators ); if ( resolvedType instanceof BasicPluralType ) { register( resolvedType ); } else if ( resolvedType == null ) { - final Class elementJavaTypeClass = elementType.getJavaTypeDescriptor().getJavaTypeClass(); - if ( elementJavaTypeClass != null && elementJavaTypeClass.isArray() && elementJavaTypeClass != byte[].class ) { + if ( isNestedArray( elementType ) ) { // No support for nested arrays, except for byte[][] throw new MappingException( "Nested arrays (with the exception of byte[][]) are not supported" ); } @@ -182,6 +185,13 @@ else if ( resolvedType == null ) { return resolvedType; } + private static boolean isNestedArray(BasicType elementType) { + final var elementJavaTypeClass = elementType.getJavaTypeDescriptor().getJavaTypeClass(); + return elementJavaTypeClass != null + && elementJavaTypeClass.isArray() + && elementJavaTypeClass != byte[].class; + } + public BasicType resolve(JavaType javaType, JdbcType jdbcType, String baseTypeName) { return resolve( javaType, jdbcType, () -> new NamedBasicTypeImpl<>( javaType, jdbcType, baseTypeName ) ); } @@ -191,7 +201,7 @@ public BasicType resolve(JavaType javaType, JdbcType jdbcType, String * JdbcType combo or create (and register) one. */ public BasicType resolve(JavaType javaType, JdbcType jdbcType, Supplier> creator) { - final BasicType registeredBasicType = registryForJdbcType( jdbcType ).get( javaType ); + final var registeredBasicType = registryForJdbcType( jdbcType ).get( javaType ); //noinspection unchecked return registeredBasicType != null ? (BasicType) registeredBasicType @@ -209,7 +219,7 @@ private BasicType createIfUnregistered( return registeredType; } else { - final BasicType createdType = creator.get(); + final var createdType = creator.get(); register( javaType, jdbcType, createdType ); return createdType; } @@ -227,14 +237,17 @@ private void register(JavaType javaType, JdbcType jdbcType, BasicType // if we are still building mappings, register this adhoc // type via a unique code. (This is to support Envers.) try { - typeConfiguration.getMetadataBuildingContext().getBootstrapContext() - .registerAdHocBasicType( createdType ); + getBootstrapContext().registerAdHocBasicType( createdType ); } catch (Exception ignore) { } } } + private BootstrapContext getBootstrapContext() { + return typeConfiguration.getMetadataBuildingContext().getBootstrapContext(); + } + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Mutations @@ -249,7 +262,7 @@ public void register(BasicType type, String key) { public void register(BasicType type, String... keys) { if ( ! isPrimed() ) { - throw new IllegalStateException( "BasicTypeRegistry not yet primed. Calls to `#register` not valid until after primed" ); + throw new IllegalStateException( "BasicTypeRegistry not yet primed. Calls to `#register` not valid until after primed" ); } if ( type == null ) { @@ -259,7 +272,7 @@ public void register(BasicType type, String... keys) { applyOrOverwriteEntry( type ); // explicit registration keys - if ( CollectionHelper.isEmpty( keys ) ) { + if ( isEmpty( keys ) ) { LOG.typeDefinedNoRegistrationKeys( type ); } else { @@ -268,8 +281,8 @@ public void register(BasicType type, String... keys) { } private void applyOrOverwriteEntry(BasicType type) { - final JdbcType jdbcType = type.getJdbcType(); - final BasicType existing = registryForJdbcType( jdbcType ).put( type.getMappedJavaType(), type ); + final var jdbcType = type.getJdbcType(); + final var existing = registryForJdbcType( jdbcType ).put( type.getMappedJavaType(), type ); if ( existing != null ) { LOG.tracef( "BasicTypeRegistry registration overwritten (%s + %s); previous =`%s`", @@ -281,7 +294,7 @@ private void applyOrOverwriteEntry(BasicType type) { } public CustomType register(UserType type, String... keys) { - final CustomType customType = new CustomType<>( type, keys, typeConfiguration ); + final var customType = new CustomType<>( type, keys, typeConfiguration ); register( customType ); return customType; } @@ -294,7 +307,7 @@ public void unregister(String... keys) { @Internal public void addTypeReferenceRegistrationKey(String typeReferenceKey, String... additionalTypeReferenceKeys) { - final BasicTypeReference basicTypeReference = typeReferencesByName.get( typeReferenceKey ); + final var basicTypeReference = typeReferencesByName.get( typeReferenceKey ); if ( basicTypeReference == null ) { throw new IllegalArgumentException( "Couldn't find type reference with name: " + typeReferenceKey ); } @@ -327,7 +340,7 @@ public void addPrimeEntry(BasicType type, String legacyTypeClassName, String[ primeRegistryEntry( type ); // Legacy name registration - if ( StringHelper.isNotEmpty( legacyTypeClassName ) ) { + if ( isNotEmpty( legacyTypeClassName ) ) { typesByName.put( legacyTypeClassName, type ); } @@ -350,7 +363,7 @@ public void addPrimeEntry(BasicTypeReference type, String legacyTypeClassName } // Legacy name registration - if ( StringHelper.isNotEmpty( legacyTypeClassName ) ) { + if ( isNotEmpty( legacyTypeClassName ) ) { typeReferencesByName.put( legacyTypeClassName, type ); } @@ -364,11 +377,11 @@ public void addPrimeEntry(BasicTypeReference type, String legacyTypeClassName } private void primeRegistryEntry(BasicType type) { - final JdbcType jdbcType = type.getJdbcType(); - final BasicType existing = registryForJdbcType( jdbcType ).get( type.getMappedJavaType() ); + final var jdbcType = type.getJdbcType(); + final var existing = registryForJdbcType( jdbcType ).get( type.getMappedJavaType() ); if ( existing != null ) { LOG.tracef( - "Skipping registration of BasicType (%s + %s); still priming. existing = %s", + "Skipping registration of BasicType (%s + %s); still priming. existing = %s", jdbcType.getFriendlyName(), type.getJavaTypeDescriptor(), existing @@ -427,7 +440,6 @@ private void applyRegistrationKeys(BasicTypeReference type, String[] keys) { // ); // } } - } } } 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 ffc7a11c6498..97bb140accdc 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 @@ -45,7 +45,6 @@ import org.hibernate.boot.spi.MetadataBuildingContext; import org.hibernate.dialect.Dialect; import org.hibernate.engine.spi.SessionFactoryImplementor; -import org.hibernate.id.uuid.LocalObjectUuidHelper; import org.hibernate.internal.SessionFactoryRegistry; import org.hibernate.jpa.spi.JpaCompliance; import org.hibernate.metamodel.mapping.BasicValuedMapping; @@ -81,6 +80,7 @@ import jakarta.persistence.TemporalType; +import static org.hibernate.id.uuid.LocalObjectUuidHelper.generateLocalObjectUuid; import static org.hibernate.query.sqm.internal.TypecheckUtil.isNumberArray; /** @@ -115,7 +115,7 @@ public class TypeConfiguration implements SessionFactoryObserver, Serializable { // private static final CoreMessageLogger log = messageLogger( Scope.class ); - private final String uuid = LocalObjectUuidHelper.generateLocalObjectUuid(); + private final String uuid = generateLocalObjectUuid(); private final Scope scope; @@ -285,8 +285,8 @@ public void sessionFactoryClosed(SessionFactory factory) { } public void addBasicTypeRegistrationContributions(List contributions) { - for ( BasicTypeRegistration basicTypeRegistration : contributions ) { - final BasicType basicType = basicTypeRegistration.getBasicType(); + for ( var basicTypeRegistration : contributions ) { + final var basicType = basicTypeRegistration.getBasicType(); basicTypeRegistry.register( basicType, @@ -594,10 +594,11 @@ private void setSessionFactory(SessionFactoryImplementor factory) { private static String getFactoryName(SessionFactoryImplementor factory) { final String factoryName = factory.getSessionFactoryOptions().getSessionFactoryName(); if ( factoryName == null ) { - final CfgXmlAccessService cfgXmlAccessService = - factory.getServiceRegistry().requireService( CfgXmlAccessService.class ); - return cfgXmlAccessService.getAggregatedConfig() == null ? null - : cfgXmlAccessService.getAggregatedConfig().getSessionFactoryName(); + final var cfgXmlAccessService = + factory.getServiceRegistry() + .requireService( CfgXmlAccessService.class ); + final var aggregatedConfig = cfgXmlAccessService.getAggregatedConfig(); + return aggregatedConfig == null ? null : aggregatedConfig.getSessionFactoryName(); } else { return factoryName; @@ -643,10 +644,10 @@ private Class entityClassForEntityName(String entityName) { private final ConcurrentMap arrayTuples = new ConcurrentHashMap<>(); public SqmBindableType resolveTupleType(List> typedNodes) { - final SqmBindableType[] components = new SqmBindableType[typedNodes.size()]; + final var components = new SqmBindableType[typedNodes.size()]; for ( int i = 0; i < typedNodes.size(); i++ ) { - final SqmTypedNode tupleElement = typedNodes.get(i); - final SqmBindableType sqmExpressible = tupleElement.getNodeType(); + final var tupleElement = typedNodes.get(i); + final var sqmExpressible = tupleElement.getNodeType(); // keep null value for Named Parameters if ( tupleElement instanceof SqmParameter && sqmExpressible == null ) { components[i] = QueryParameterJavaObjectType.INSTANCE; @@ -763,7 +764,7 @@ public BasicType getBasicTypeForJavaType(Class javaType) { } public BasicType getBasicTypeForJavaType(Type javaType) { - final BasicType existing = basicTypeByJavaType.get( javaType ); + final var existing = basicTypeByJavaType.get( javaType ); if ( existing != null ) { //noinspection unchecked return (BasicType) existing; @@ -865,7 +866,7 @@ public static TemporalType getSqlTemporalType(MappingModelExpressible type) { } else if ( type instanceof EmbeddableValuedModelPart embeddableValuedModelPart ) { // Handle the special embeddables for emulated offset/timezone handling - final Class javaTypeClass = embeddableValuedModelPart.getJavaType().getJavaTypeClass(); + final var javaTypeClass = embeddableValuedModelPart.getJavaType().getJavaTypeClass(); if ( javaTypeClass == OffsetDateTime.class || javaTypeClass == ZonedDateTime.class ) { return TemporalType.TIMESTAMP;