light refactoring of ListResultsConsumer

Author: gavinking

hibernate-core/src/main/java/org/hibernate/LockOptions.java

@@ -16,7 +16,6 @@
 import jakarta.persistence.PessimisticLockScope;
 import jakarta.persistence.RefreshOption;
 import org.hibernate.query.Query;
-import org.hibernate.query.spi.QueryOptions;
 
 import static jakarta.persistence.PessimisticLockScope.NORMAL;
 import static java.util.Collections.emptySet;
@@ -452,7 +451,7 @@ public LockOptions setLockScope(PessimisticLockScope scope) {
 	 *         has not been overridden.
 	 *
 	 * @see org.hibernate.jpa.HibernateHints#HINT_FOLLOW_ON_LOCKING
-	 * @see org.hibernate.dialect.Dialect#useFollowOnLocking(String, QueryOptions)
+	 * @see org.hibernate.dialect.Dialect#useFollowOnLocking(String, org.hibernate.query.spi.QueryOptions)
 	 */
 	public Boolean getFollowOnLocking() {
 		return followOnLocking;

hibernate-core/src/main/java/org/hibernate/sql/results/spi/ListResultsConsumer.java

@@ -13,7 +13,7 @@
 import org.hibernate.engine.spi.PersistenceContext;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.query.ResultListTransformer;
-import org.hibernate.query.spi.QueryOptions;
+import org.hibernate.sql.exec.spi.ExecutionContext;
 import org.hibernate.sql.results.internal.RowProcessingStateStandardImpl;
 import org.hibernate.sql.results.jdbc.internal.JdbcValuesSourceProcessingStateStandardImpl;
 import org.hibernate.sql.results.jdbc.spi.JdbcValues;
@@ -46,23 +46,13 @@ public class ListResultsConsumer<R> implements ResultsConsumer<List<R>, R> {
 
 	@SuppressWarnings("unchecked")
 	public static <R> ListResultsConsumer<R> instance(UniqueSemantic uniqueSemantic) {
-		switch ( uniqueSemantic ) {
-			case ASSERT: {
-				return (ListResultsConsumer<R>) ERROR_DUP_CONSUMER;
-			}
-			case FILTER: {
-				return (ListResultsConsumer<R>) DE_DUP_CONSUMER;
-			}
-			case NEVER: {
-				return (ListResultsConsumer<R>) NEVER_DE_DUP_CONSUMER;
-			}
-			case ALLOW: {
-				return (ListResultsConsumer<R>) ALLOW_DE_DUP_CONSUMER;
-			}
-			default: {
-				return (ListResultsConsumer<R>) IGNORE_DUP_CONSUMER;
-			}
-		}
+		return (ListResultsConsumer<R>) switch ( uniqueSemantic ) {
+			case ASSERT -> ERROR_DUP_CONSUMER;
+			case FILTER -> DE_DUP_CONSUMER;
+			case NEVER -> NEVER_DE_DUP_CONSUMER;
+			case ALLOW -> ALLOW_DE_DUP_CONSUMER;
+			default -> IGNORE_DUP_CONSUMER;
+		};
 	}
 
 	/**
@@ -157,59 +147,26 @@ public List<R> consume(
 			JdbcValuesSourceProcessingStateStandardImpl jdbcValuesSourceProcessingState,
 			RowProcessingStateStandardImpl rowProcessingState,
 			RowReader<R> rowReader) {
-		final PersistenceContext persistenceContext = session.getPersistenceContextInternal();
-		final TypeConfiguration typeConfiguration = session.getTypeConfiguration();
-		final QueryOptions queryOptions = rowProcessingState.getQueryOptions();
-
 		rowReader.startLoading( rowProcessingState );
 
 		RuntimeException ex = null;
+		final PersistenceContext persistenceContext = session.getPersistenceContextInternal();
 		persistenceContext.beforeLoad();
 		persistenceContext.getLoadContexts().register( jdbcValuesSourceProcessingState );
 		try {
 			final JavaType<R> domainResultJavaType = resolveDomainResultJavaType(
 					rowReader.getDomainResultResultJavaType(),
 					rowReader.getResultJavaTypes(),
-					typeConfiguration
+					session.getTypeConfiguration()
 			);
 
 			final boolean isEntityResultType = domainResultJavaType instanceof EntityJavaType;
 			final int initialCollectionSize = Math.min( jdbcValues.getResultCountEstimate(), INITIAL_COLLECTION_SIZE_LIMIT );
-
-			final Results<R> results;
-			if ( isEntityResultType
-					&& ( uniqueSemantic == UniqueSemantic.ALLOW
-						|| uniqueSemantic == UniqueSemantic.FILTER ) ) {
-				results = new EntityResult<>( domainResultJavaType, initialCollectionSize );
-			}
-			else {
-				results = new Results<>( domainResultJavaType, initialCollectionSize );
-			}
-
-			final int readRows;
-			if ( uniqueSemantic == UniqueSemantic.FILTER
-					|| uniqueSemantic == UniqueSemantic.ASSERT && rowReader.hasCollectionInitializers()
-					|| uniqueSemantic == UniqueSemantic.ALLOW && isEntityResultType ) {
-				readRows = readUnique( rowProcessingState, rowReader, results );
-			}
-			else if ( uniqueSemantic == UniqueSemantic.ASSERT ) {
-				readRows = readUniqueAssert( rowProcessingState, rowReader, results );
-			}
-			else {
-				readRows = read( rowProcessingState, rowReader, results );
-			}
-
+			final Results<R> results = createResults( isEntityResultType, domainResultJavaType, initialCollectionSize );
+			final int readRows = readRows( rowProcessingState, rowReader, isEntityResultType, results );
 			rowReader.finishUp( rowProcessingState );
 			jdbcValuesSourceProcessingState.finishUp( readRows > 1 );
-
-			//noinspection unchecked
-			final ResultListTransformer<R> resultListTransformer =
-					(ResultListTransformer<R>) queryOptions.getResultListTransformer();
-			if ( resultListTransformer != null ) {
-				return resultListTransformer.transformList( results.getResults() );
-			}
-
-			return results.getResults();
+			return transformList( rowProcessingState, results );
 		}
 		catch (RuntimeException e) {
 			ex = e;
@@ -238,6 +195,47 @@ else if ( uniqueSemantic == UniqueSemantic.ASSERT ) {
 		throw new IllegalStateException( "Should not reach this" );
 	}
 
+	private static <R> List<R> transformList(ExecutionContext executionContext, Results<R> results) {
+		final ResultListTransformer<R> transformer = getResultListTransformer( executionContext );
+		return transformer == null ? results.getResults() : transformer.transformList( results.getResults() );
+	}
+
+	@SuppressWarnings("unchecked")
+	private static <R> ResultListTransformer<R> getResultListTransformer(ExecutionContext executionContext) {
+		return (ResultListTransformer<R>) executionContext.getQueryOptions().getResultListTransformer();
+	}
+
+	private Results<R> createResults(
+			boolean isEntityResultType,
+			JavaType<R> domainResultJavaType,
+			int initialCollectionSize) {
+		if ( isEntityResultType
+			&& ( uniqueSemantic == UniqueSemantic.ALLOW || uniqueSemantic == UniqueSemantic.FILTER ) ) {
+			return new EntityResult<>( domainResultJavaType, initialCollectionSize );
+		}
+		else {
+			return new Results<>( domainResultJavaType, initialCollectionSize );
+		}
+	}
+
+	private int readRows(
+			RowProcessingStateStandardImpl rowProcessingState,
+			RowReader<R> rowReader,
+			boolean isEntityResultType,
+			Results<R> results) {
+		if ( uniqueSemantic == UniqueSemantic.FILTER
+				|| uniqueSemantic == UniqueSemantic.ASSERT && rowReader.hasCollectionInitializers()
+				|| uniqueSemantic == UniqueSemantic.ALLOW && isEntityResultType ) {
+			return readUnique( rowProcessingState, rowReader, results );
+		}
+		else if ( uniqueSemantic == UniqueSemantic.ASSERT ) {
+			return readUniqueAssert( rowProcessingState, rowReader, results );
+		}
+		else {
+			return read( rowProcessingState, rowReader, results );
+		}
+	}
+
 	private static <R> int read(
 			RowProcessingStateStandardImpl rowProcessingState,
 			RowReader<R> rowReader,