various cleanups

Author: gavinking

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

@@ -7,7 +7,6 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
-import java.util.concurrent.Callable;
 
 import org.hibernate.AnnotationException;
 import org.hibernate.HibernateException;
@@ -72,13 +71,10 @@
 import org.hibernate.internal.CoreLogging;
 import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.internal.log.DeprecationLogger;
-import org.hibernate.internal.util.NullnessHelper;
-import org.hibernate.internal.util.collections.CollectionHelper;
 import org.hibernate.metamodel.CollectionClassification;
 import org.hibernate.query.sqm.function.SqmFunctionDescriptor;
 import org.hibernate.query.sqm.function.SqmFunctionRegistry;
 import org.hibernate.service.ServiceRegistry;
-import org.hibernate.service.spi.ServiceException;
 import org.hibernate.type.BasicType;
 import org.hibernate.type.SqlTypes;
 import org.hibernate.type.WrapperArrayHandling;
@@ -95,7 +91,9 @@
 import static org.hibernate.cfg.AvailableSettings.WRAPPER_ARRAY_HANDLING;
 import static org.hibernate.cfg.MappingSettings.XML_FORMAT_MAPPER_LEGACY_FORMAT;
 import static org.hibernate.engine.config.spi.StandardConverters.BOOLEAN;
+import static org.hibernate.internal.util.NullnessHelper.coalesceSuppliedValues;
 import static org.hibernate.internal.util.StringHelper.nullIfEmpty;
+import static org.hibernate.internal.util.collections.CollectionHelper.isNotEmpty;
 
 /**
  * @author Steve Ebersole
@@ -115,16 +113,15 @@ public static StandardServiceRegistry getStandardServiceRegistry(ServiceRegistry
 		if ( serviceRegistry == null ) {
 			throw new HibernateException( "ServiceRegistry passed to MetadataBuilder cannot be null" );
 		}
-
-		if ( serviceRegistry instanceof StandardServiceRegistry ) {
-			return (StandardServiceRegistry) serviceRegistry;
+		else if ( serviceRegistry instanceof StandardServiceRegistry standardServiceRegistry ) {
+			return standardServiceRegistry;
 		}
-		else if ( serviceRegistry instanceof BootstrapServiceRegistry ) {
+		else if ( serviceRegistry instanceof BootstrapServiceRegistry bootstrapServiceRegistry ) {
 			log.debug(
 					"ServiceRegistry passed to MetadataBuilder was a BootstrapServiceRegistry; this likely won't end well " +
 							"if attempt is made to build SessionFactory"
 			);
-			return new StandardServiceRegistryBuilder( (BootstrapServiceRegistry) serviceRegistry ).build();
+			return new StandardServiceRegistryBuilder( bootstrapServiceRegistry ).build();
 		}
 		else {
 			throw new HibernateException(
@@ -443,8 +440,9 @@ public MetadataImplementor build() {
 
 		final MetadataImplementor bootModel = MetadataBuildingProcess.build( sources, bootstrapContext, options );
 
-		if ( CollectionHelper.isNotEmpty( sources.getHbmXmlBindings() ) ) {
-			final ConfigurationService configurationService = bootstrapContext.getServiceRegistry().getService( ConfigurationService.class );
+		if ( isNotEmpty( sources.getHbmXmlBindings() ) ) {
+			final ConfigurationService configurationService =
+					bootstrapContext.getServiceRegistry().getService( ConfigurationService.class );
 			final boolean transformHbm = configurationService != null
 					&& configurationService.getSetting( MappingSettings.TRANSFORM_HBM_XML, BOOLEAN,false );
 
@@ -750,19 +748,14 @@ else if ( value instanceof AccessType accessType ) {
 					null
 			) );
 
-			implicitNamingStrategy = strategySelector.resolveDefaultableStrategy(
+			implicitNamingStrategy = strategySelector.<ImplicitNamingStrategy>resolveDefaultableStrategy(
 					ImplicitNamingStrategy.class,
 					configService.getSettings().get( AvailableSettings.IMPLICIT_NAMING_STRATEGY ),
-					new Callable<>() {
-						@Override
-						public ImplicitNamingStrategy call() {
-							return strategySelector.resolveDefaultableStrategy(
-									ImplicitNamingStrategy.class,
-									"default",
-									ImplicitNamingStrategyJpaCompliantImpl.INSTANCE
-							);
-						}
-					}
+					() -> strategySelector.resolveDefaultableStrategy(
+							ImplicitNamingStrategy.class,
+							"default",
+							ImplicitNamingStrategyJpaCompliantImpl.INSTANCE
+					)
 			);
 
 			physicalNamingStrategy = strategySelector.resolveDefaultableStrategy(
@@ -771,19 +764,14 @@ public ImplicitNamingStrategy call() {
 					PhysicalNamingStrategyStandardImpl.INSTANCE
 			);
 
-			columnOrderingStrategy = strategySelector.resolveDefaultableStrategy(
+			columnOrderingStrategy = strategySelector.<ColumnOrderingStrategy>resolveDefaultableStrategy(
 					ColumnOrderingStrategy.class,
 					configService.getSettings().get( AvailableSettings.COLUMN_ORDERING_STRATEGY ),
-					new Callable<>() {
-						@Override
-						public ColumnOrderingStrategy call() {
-							return strategySelector.resolveDefaultableStrategy(
-									ColumnOrderingStrategy.class,
-									"default",
-									ColumnOrderingStrategyStandard.INSTANCE
-							);
-						}
-					}
+					() -> strategySelector.resolveDefaultableStrategy(
+							ColumnOrderingStrategy.class,
+							"default",
+							ColumnOrderingStrategyStandard.INSTANCE
+					)
 			);
 
 			useNationalizedCharacterData = configService.getSetting(
@@ -822,14 +810,7 @@ public TimeZoneStorageStrategy getDefaultTimeZoneStorage() {
 
 		@Override
 		public TimeZoneSupport getTimeZoneSupport() {
-			try {
-				return serviceRegistry.requireService( JdbcServices.class )
-						.getDialect()
-						.getTimeZoneSupport();
-			}
-			catch ( ServiceException se ) {
-				return TimeZoneSupport.NONE;
-			}
+			return getTypeConfiguration().getCurrentBaseSqlTypeIndicators().getDialect().getTimeZoneSupport();
 		}
 
 		private TimeZoneStorageStrategy toTimeZoneStorageStrategy(TimeZoneSupport timeZoneSupport) {
@@ -844,20 +825,16 @@ private TimeZoneStorageStrategy toTimeZoneStorageStrategy(TimeZoneSupport timeZo
 				case NORMALIZE -> TimeZoneStorageStrategy.NORMALIZE;
 				case NORMALIZE_UTC -> TimeZoneStorageStrategy.NORMALIZE_UTC;
 				case AUTO -> switch (timeZoneSupport) {
-					case NATIVE ->
-							// if the db has native support for timezones, we use that, not a column
-							TimeZoneStorageStrategy.NATIVE;
-					case NORMALIZE, NONE ->
-							// otherwise we use a separate column
-							TimeZoneStorageStrategy.COLUMN;
+					// if the db has native support for timezones, we use that, not a column
+					case NATIVE -> TimeZoneStorageStrategy.NATIVE;
+					// otherwise we use a separate column
+					case NORMALIZE, NONE -> TimeZoneStorageStrategy.COLUMN;
 				};
 				case DEFAULT -> switch (timeZoneSupport) {
-					case NATIVE ->
-							// if the db has native support for timezones, we use that, and don't normalize
-							TimeZoneStorageStrategy.NATIVE;
-					case NORMALIZE, NONE ->
-							// otherwise we normalize things to UTC
-							TimeZoneStorageStrategy.NORMALIZE_UTC;
+					// if the db has native support for timezones, we use that, and don't normalize
+					case NATIVE -> TimeZoneStorageStrategy.NATIVE;
+					// otherwise we normalize things to UTC
+					case NORMALIZE, NONE -> TimeZoneStorageStrategy.NORMALIZE_UTC;
 				};
 			};
 		}
@@ -979,9 +956,7 @@ public void apply(JpaOrmXmlPersistenceUnitDefaults jpaOrmXmlPersistenceUnitDefau
 			}
 
 			if ( mappingDefaults.getImplicitSchemaName() == null ) {
-				mappingDefaults.implicitSchemaName = nullIfEmpty(
-						jpaOrmXmlPersistenceUnitDefaults.getDefaultSchemaName()
-				);
+				mappingDefaults.implicitSchemaName = nullIfEmpty( jpaOrmXmlPersistenceUnitDefaults.getDefaultSchemaName() );
 			}
 		}
 
@@ -1017,27 +992,28 @@ private static TimeZoneStorageType resolveTimeZoneStorageStrategy(
 	private static WrapperArrayHandling resolveWrapperArrayHandling(
 			ConfigurationService configService,
 			StandardServiceRegistry serviceRegistry) {
-		final WrapperArrayHandling setting = NullnessHelper.coalesceSuppliedValues(
+		final WrapperArrayHandling setting = coalesceSuppliedValues(
 				() -> configService.getSetting(
 						WRAPPER_ARRAY_HANDLING,
 						WrapperArrayHandling::interpretExternalSettingLeniently
 				),
 				() -> resolveFallbackWrapperArrayHandling( configService )
 		);
 
-		if ( setting == WrapperArrayHandling.PICK ) {
-			final Dialect dialect = serviceRegistry.requireService( JdbcServices.class ).getDialect();
-			if ( dialect.supportsStandardArrays()
-					&& ( dialect.getPreferredSqlTypeCodeForArray() == SqlTypes.ARRAY
-						|| dialect.getPreferredSqlTypeCodeForArray() == SqlTypes.SQLXML ) ) {
-				return WrapperArrayHandling.ALLOW;
-			}
-			else {
-				return WrapperArrayHandling.LEGACY;
-			}
-		}
+		final Dialect dialect = serviceRegistry.requireService( JdbcServices.class ).getDialect();
+		return setting == WrapperArrayHandling.PICK ? pickWrapperArrayHandling( dialect ) : setting;
 
-		return setting;
+	}
+
+	private static WrapperArrayHandling pickWrapperArrayHandling(Dialect dialect) {
+		if ( dialect.supportsStandardArrays()
+			 && ( dialect.getPreferredSqlTypeCodeForArray() == SqlTypes.ARRAY
+				 || dialect.getPreferredSqlTypeCodeForArray() == SqlTypes.SQLXML ) ) {
+			return WrapperArrayHandling.ALLOW;
+		}
+		else {
+			return WrapperArrayHandling.LEGACY;
+		}
 	}
 
 	private static WrapperArrayHandling resolveFallbackWrapperArrayHandling(

hibernate-core/src/main/java/org/hibernate/dialect/XmlHelper.java

@@ -1124,19 +1124,15 @@ public static CollectionTags determineCollectionTags(BasicPluralJavaType<?> plur
 		}
 		//noinspection unchecked
 		final JavaType<Object> javaType = (JavaType<Object>) pluralJavaType;
-		final LazySessionWrapperOptions lazySessionWrapperOptions = new LazySessionWrapperOptions( sessionFactory );
 		// Produce the XML string for a collection with a null element to find out the root and element tag names
 		final String nullElementXml;
-		try {
+		try ( final LazySessionWrapperOptions lazySessionWrapperOptions = new LazySessionWrapperOptions( sessionFactory ) ) {
 			nullElementXml = sessionFactory.getSessionFactoryOptions().getXmlFormatMapper().toString(
 					javaType.fromString( "{null}" ),
 					javaType,
 					lazySessionWrapperOptions
 			);
 		}
-		finally {
-			lazySessionWrapperOptions.cleanup();
-		}
 
 		// There must be an end tag for the root, so find that first
 		final int rootCloseTagPosition = nullElementXml.lastIndexOf( '<' );

hibernate-core/src/main/java/org/hibernate/dialect/aggregate/OracleAggregateSupport.java

@@ -312,6 +312,7 @@ private static WrapperOptions getWrapperOptions(TypeConfiguration typeConfigurat
 			return typeConfiguration.getSessionFactory().getWrapperOptions();
 		}
 		catch (HibernateException e) {
+			// before we have a SessionFactory, no useful WrapperOptions to pass
 			return null;
 		}
 	}
@@ -549,16 +550,11 @@ private String determineJsonTypeName(SelectableMapping aggregateColumn) {
 		final String columnDefinition = aggregateColumn.getColumnDefinition();
 		if ( columnDefinition == null ) {
 			assert aggregateColumn.getJdbcMapping().getJdbcType().getDefaultSqlTypeCode() == JSON;
-			switch ( jsonSupport ) {
-				case OSON:
-					return "json";
-				case MERGEPATCH:
-				case QUERY_AND_PATH:
-				case QUERY:
-					return "blob";
-				case NONE:
-					return "clob";
-			}
+			return switch ( jsonSupport ) {
+				case OSON -> "json";
+				case MERGEPATCH, QUERY_AND_PATH, QUERY -> "blob";
+				case NONE -> "clob";
+			};
 		}
 		return columnDefinition;
 	}

hibernate-core/src/main/java/org/hibernate/dialect/function/NumberSeriesGenerateSeriesFunction.java

@@ -485,18 +485,14 @@ private String getStepExpression(@Nullable Expression explicitStep, String table
 		private String getExpression(Expression expression, String tableIdentifierVariable, String syntheticColumnName, SqmToSqlAstConverter walker) {
 			if ( expression instanceof Literal literal ) {
 				final SessionFactoryImplementor sessionFactory = walker.getCreationContext().getSessionFactory();
-				final LazySessionWrapperOptions wrapperOptions = new LazySessionWrapperOptions( sessionFactory );
-				try {
+				try ( final LazySessionWrapperOptions wrapperOptions = new LazySessionWrapperOptions( sessionFactory ) ) {
 					//noinspection unchecked
 					return literal.getJdbcMapping().getJdbcLiteralFormatter().toJdbcLiteral(
 							literal.getLiteralValue(),
 							sessionFactory.getJdbcServices().getDialect(),
 							wrapperOptions
 					);
 				}
-				finally {
-					wrapperOptions.cleanup();
-				}
 			}
 			else if ( expression instanceof ColumnReference columnReference ) {
 				return columnReference.getExpressionText();

hibernate-core/src/main/java/org/hibernate/engine/spi/AbstractDelegatingWrapperOptions.java

@@ -12,7 +12,11 @@
 /**
  * @author Christian Beikov
  * @author Andrea Boriero
+ *
+ * @deprecated This isn't bringing any value, since {@link SessionImplementor}
+ *             already extends {@link WrapperOptions}.
  */
+@Deprecated(since = "7", forRemoval = true)
 public abstract class AbstractDelegatingWrapperOptions implements WrapperOptions {
 
 	/**

hibernate-core/src/main/java/org/hibernate/engine/spi/LazySessionWrapperOptions.java

@@ -7,23 +7,37 @@
 import java.util.TimeZone;
 
 import org.hibernate.Internal;
+import org.hibernate.dialect.Dialect;
+import org.hibernate.engine.jdbc.LobCreator;
+import org.hibernate.internal.FastSessionServices;
 import org.hibernate.type.descriptor.WrapperOptions;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 /**
- * A lazy session implementation that is needed for rendering literals.
- * Usually, only the {@link WrapperOptions} interface is needed,
- * but for creating LOBs, it might be to have a full-blown session.
+ * An implementation of {@link WrapperOptions} used for rendering SQL literals,
+ * which is backed by the {@link SessionFactoryImplementor}, and which
+ * {@linkplain SessionFactoryImplementor#openTemporarySession lazily creates a
+ * temporary session if needed.} The temporary session will only be created when
+ * dealing with LOBs.
+ * <p>
+ * This object is {@link AutoCloseable}, and <em>must</em> be explicitly cleaned
+ * up by its creator.
+ *
+ * @apiNote This thing is nasty, and we should find a better way to solve the problem.
+ * Whenever possible, just use {@link SessionFactoryImplementor#getWrapperOptions()}
+ * instead.
  */
 @Internal
-public class LazySessionWrapperOptions extends AbstractDelegatingWrapperOptions {
+public class LazySessionWrapperOptions implements WrapperOptions, AutoCloseable {
 
 	private final SessionFactoryImplementor sessionFactory;
+	private final FastSessionServices fastSessionServices;
 	private @Nullable SessionImplementor session;
 
 	public LazySessionWrapperOptions(SessionFactoryImplementor sessionFactory) {
 		this.sessionFactory = sessionFactory;
+		fastSessionServices = sessionFactory.getFastSessionServices();
 	}
 
 	public void cleanup() {
@@ -34,16 +48,14 @@ public void cleanup() {
 	}
 
 	@Override
-	protected SessionImplementor delegate() {
-		if ( session == null ) {
-			session = sessionFactory.openTemporarySession();
-		}
-		return session;
+	public void close() {
+		cleanup();
 	}
 
 	@Override
 	public SharedSessionContractImplementor getSession() {
-		return delegate();
+		session = sessionFactory.openTemporarySession();
+		return session;
 	}
 
 	@Override
@@ -53,16 +65,26 @@ public SessionFactoryImplementor getSessionFactory() {
 
 	@Override
 	public boolean useStreamForLobBinding() {
-		return sessionFactory.getFastSessionServices().useStreamForLobBinding();
+		return fastSessionServices.useStreamForLobBinding;
 	}
 
 	@Override
 	public int getPreferredSqlTypeCodeForBoolean() {
-		return sessionFactory.getFastSessionServices().getPreferredSqlTypeCodeForBoolean();
+		return fastSessionServices.preferredSqlTypeCodeForBoolean;
 	}
 
 	@Override
 	public TimeZone getJdbcTimeZone() {
-		return sessionFactory.getSessionFactoryOptions().getJdbcTimeZone();
+		return fastSessionServices.jdbcTimeZone;
+	}
+
+	@Override
+	public Dialect getDialect() {
+		return fastSessionServices.dialect;
+	}
+
+	@Override
+	public LobCreator getLobCreator() {
+		return fastSessionServices.jdbcServices.getLobCreator( getSession() );
 	}
 }