Rework multi-table handling and non-select query plan code to allow caching and help Hibernate Reactive

Author: beikov

hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/MappingModelCreationHelper.java

@@ -1558,9 +1558,9 @@ else if ( modelPart instanceof VirtualModelPart ) {
 	}
 
 	public static Expression buildColumnReferenceExpression(
-			TableGroup tableGroup,
+			@Nullable TableGroup tableGroup,
 			ModelPart modelPart,
-			SqlExpressionResolver sqlExpressionResolver,
+			@Nullable SqlExpressionResolver sqlExpressionResolver,
 			SessionFactoryImplementor sessionFactory) {
 		final int jdbcTypeCount = modelPart.getJdbcTypeCount();
 		if ( modelPart instanceof EmbeddableValuedModelPart ) {

hibernate-core/src/main/java/org/hibernate/query/sqm/internal/AbstractMultiTableMutationQueryPlan.java

@@ -0,0 +1,106 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.query.sqm.internal;
+
+import org.hibernate.action.internal.BulkOperationCleanupAction;
+import org.hibernate.query.spi.DomainQueryExecutionContext;
+import org.hibernate.query.spi.NonSelectQueryPlan;
+import org.hibernate.query.sqm.mutation.spi.MultiTableHandler;
+import org.hibernate.query.sqm.mutation.spi.MultiTableHandlerBuildResult;
+import org.hibernate.query.sqm.tree.SqmDmlStatement;
+import org.hibernate.sql.exec.spi.JdbcParameterBindings;
+
+
+/**
+ * @since 7.1
+ */
+public abstract class AbstractMultiTableMutationQueryPlan<S extends SqmDmlStatement<?>, F> implements NonSelectQueryPlan {
+	private final S statement;
+	private final DomainParameterXref domainParameterXref;
+	private final F strategy;
+
+	private volatile MultiTableHandler handler;
+
+	public AbstractMultiTableMutationQueryPlan(S statement, DomainParameterXref domainParameterXref, F strategy) {
+		this.statement = statement;
+		this.domainParameterXref = domainParameterXref;
+		this.strategy = strategy;
+	}
+
+	protected abstract MultiTableHandlerBuildResult buildHandler(
+			S statement,
+			DomainParameterXref domainParameterXref,
+			F strategy,
+			DomainQueryExecutionContext context);
+
+	@Override
+	public int executeUpdate(DomainQueryExecutionContext context) {
+		BulkOperationCleanupAction.schedule( context.getSession(), statement );
+		MultiTableHandler localCopy = handler;
+		JdbcParameterBindings jdbcParameterBindings = null;
+
+		if ( localCopy == null ) {
+			synchronized (this) {
+				localCopy = handler;
+				if ( localCopy == null ) {
+					final MultiTableHandlerBuildResult buildResult = buildHandler(
+							statement,
+							domainParameterXref,
+							strategy,
+							context
+					);
+					localCopy = buildResult.multiTableHandler();
+					jdbcParameterBindings = buildResult.firstJdbcParameterBindings();
+					handler = localCopy;
+				}
+				else {
+					// If the translation depends on parameter bindings or it isn't compatible with the current query options,
+					// we have to rebuild the JdbcSelect, which is still better than having to translate from SQM to SQL AST again
+					if ( localCopy.dependsOnParameterBindings() ) {
+						jdbcParameterBindings = localCopy.createJdbcParameterBindings( context );
+					}
+					// If the translation depends on the limit or lock options, we have to rebuild the JdbcSelect
+					// We could avoid this by putting the lock options into the cache key
+					if ( !localCopy.isCompatibleWith( jdbcParameterBindings, context.getQueryOptions() ) ) {
+						final MultiTableHandlerBuildResult buildResult = buildHandler(
+								statement,
+								domainParameterXref,
+								strategy,
+								context
+						);
+						localCopy = buildResult.multiTableHandler();
+						jdbcParameterBindings = buildResult.firstJdbcParameterBindings();
+						handler = localCopy;
+					}
+				}
+			}
+		}
+		else {
+			// If the translation depends on parameter bindings or it isn't compatible with the current query options,
+			// we have to rebuild the JdbcSelect, which is still better than having to translate from SQM to SQL AST again
+			if ( localCopy.dependsOnParameterBindings() ) {
+				jdbcParameterBindings = localCopy.createJdbcParameterBindings( context );
+			}
+			// If the translation depends on the limit or lock options, we have to rebuild the JdbcSelect
+			// We could avoid this by putting the lock options into the cache key
+			if ( !localCopy.isCompatibleWith( jdbcParameterBindings, context.getQueryOptions() ) ) {
+				final MultiTableHandlerBuildResult buildResult = buildHandler(
+						statement,
+						domainParameterXref,
+						strategy,
+						context
+				);
+				localCopy = buildResult.multiTableHandler();
+				jdbcParameterBindings = buildResult.firstJdbcParameterBindings();
+				handler = localCopy;
+			}
+		}
+		if ( jdbcParameterBindings == null ) {
+			jdbcParameterBindings = localCopy.createJdbcParameterBindings( context );
+		}
+		return localCopy.execute( jdbcParameterBindings, context );
+	}
+
+}

hibernate-core/src/main/java/org/hibernate/query/sqm/internal/CacheableSqmInterpretation.java

@@ -0,0 +1,26 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.query.sqm.internal;
+
+import org.hibernate.metamodel.mapping.MappingModelExpressible;
+import org.hibernate.query.spi.QueryParameterImplementor;
+import org.hibernate.query.sqm.tree.expression.SqmParameter;
+import org.hibernate.sql.ast.tree.Statement;
+import org.hibernate.sql.exec.spi.JdbcOperationQuery;
+import org.hibernate.sql.exec.spi.JdbcParametersList;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @since 7.1
+ */
+public record CacheableSqmInterpretation<S extends Statement, J extends JdbcOperationQuery>(
+		S statement,
+		J jdbcOperation,
+		Map<QueryParameterImplementor<?>, Map<SqmParameter<?>, List<JdbcParametersList>>> jdbcParamsXref,
+		Map<SqmParameter<?>, MappingModelExpressible<?>> sqmParameterMappingModelTypes) {
+
+}

hibernate-core/src/main/java/org/hibernate/query/sqm/internal/ConcreteSqmSelectQueryPlan.java

@@ -18,12 +18,12 @@
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.engine.spi.SubselectFetch;
 import org.hibernate.internal.EmptyScrollableResults;
+import org.hibernate.internal.util.MutableObject;
 import org.hibernate.metamodel.mapping.MappingModelExpressible;
 import org.hibernate.query.QueryTypeMismatchException;
 import org.hibernate.query.TupleTransformer;
 import org.hibernate.query.spi.DomainQueryExecutionContext;
 import org.hibernate.query.spi.QueryOptions;
-import org.hibernate.query.spi.QueryParameterImplementor;
 import org.hibernate.query.spi.ScrollableResultsImplementor;
 import org.hibernate.query.spi.SelectQueryPlan;
 import org.hibernate.query.sqm.spi.SqmParameterMappingModelResolutionAccess;
@@ -79,7 +79,7 @@ public class ConcreteSqmSelectQueryPlan<R> implements SelectQueryPlan<R> {
 	private final SqmInterpreter<List<R>, Void> listInterpreter;
 	private final SqmInterpreter<ScrollableResultsImplementor<R>, ScrollMode> scrollInterpreter;
 
-	private volatile CacheableSqmInterpretation cacheableSqmInterpretation;
+	private volatile CacheableSqmInterpretation<SelectStatement, JdbcOperationQuerySelect> cacheableSqmInterpretation;
 
 	public ConcreteSqmSelectQueryPlan(
 			SqmSelectStatement<?> sqm,
@@ -97,16 +97,16 @@ public ConcreteSqmSelectQueryPlan(
 						: ListResultsConsumer.UniqueSemantic.ALLOW;
 		this.executeQueryInterpreter = (resultsConsumer, executionContext, sqmInterpretation, jdbcParameterBindings) -> {
 			final SharedSessionContractImplementor session = executionContext.getSession();
-			final JdbcOperationQuerySelect jdbcSelect = sqmInterpretation.getJdbcSelect();
+			final JdbcOperationQuerySelect jdbcSelect = sqmInterpretation.jdbcOperation();
 			try {
 				final SubselectFetch.RegistrationHandler subSelectFetchKeyHandler = SubselectFetch.createRegistrationHandler(
 						session.getPersistenceContext().getBatchFetchQueue(),
-						sqmInterpretation.selectStatement,
+						sqmInterpretation.statement(),
 						JdbcParametersList.empty(),
 						jdbcParameterBindings
 				);
 				session.autoFlushIfRequired( jdbcSelect.getAffectedTableNames(), true );
-				final Expression fetchExpression = sqmInterpretation.selectStatement.getQueryPart()
+				final Expression fetchExpression = sqmInterpretation.statement().getQueryPart()
 						.getFetchClauseExpression();
 				final int resultCountEstimate = fetchExpression != null
 						? interpretIntExpression( fetchExpression, jdbcParameterBindings )
@@ -127,17 +127,17 @@ public ConcreteSqmSelectQueryPlan(
 		};
 		this.listInterpreter = (unused, executionContext, sqmInterpretation, jdbcParameterBindings) -> {
 			final SharedSessionContractImplementor session = executionContext.getSession();
-			final JdbcOperationQuerySelect jdbcSelect = sqmInterpretation.getJdbcSelect();
+			final JdbcOperationQuerySelect jdbcSelect = sqmInterpretation.jdbcOperation();
 			try {
 				final SubselectFetch.RegistrationHandler subSelectFetchKeyHandler = SubselectFetch.createRegistrationHandler(
 						session.getPersistenceContext().getBatchFetchQueue(),
-						sqmInterpretation.selectStatement,
+						sqmInterpretation.statement(),
 						JdbcParametersList.empty(),
 						jdbcParameterBindings
 				);
 				session.autoFlushIfRequired( jdbcSelect.getAffectedTableNames(), true );
 				final Expression fetchExpression =
-						sqmInterpretation.selectStatement.getQueryPart()
+						sqmInterpretation.statement().getQueryPart()
 								.getFetchClauseExpression();
 				final int resultCountEstimate = fetchExpression != null
 						? interpretIntExpression( fetchExpression, jdbcParameterBindings )
@@ -160,7 +160,7 @@ public ConcreteSqmSelectQueryPlan(
 
 		this.scrollInterpreter = (scrollMode, executionContext, sqmInterpretation, jdbcParameterBindings) -> {
 			final SharedSessionContractImplementor session = executionContext.getSession();
-			final JdbcOperationQuerySelect jdbcSelect = sqmInterpretation.getJdbcSelect();
+			final JdbcOperationQuerySelect jdbcSelect = sqmInterpretation.jdbcOperation();
 			try {
 //				final SubselectFetch.RegistrationHandler subSelectFetchKeyHandler = SubselectFetch.createRegistrationHandler(
 //						executionContext.getSession().getPersistenceContext().getBatchFetchQueue(),
@@ -173,7 +173,7 @@ public ConcreteSqmSelectQueryPlan(
 						session.getFactory().getJdbcServices().getJdbcSelectExecutor();
 				session.autoFlushIfRequired( jdbcSelect.getAffectedTableNames(), true );
 				final Expression fetchExpression =
-						sqmInterpretation.selectStatement.getQueryPart()
+						sqmInterpretation.statement().getQueryPart()
 								.getFetchClauseExpression();
 				final int resultCountEstimate = fetchExpression != null
 						? interpretIntExpression( fetchExpression, jdbcParameterBindings )
@@ -401,7 +401,7 @@ private <T, X> T withCacheableSqmInterpretation(DomainQueryExecutionContext exec
 		//		to protect access.  However, synchronized is much simpler here.  We will verify
 		// 		during throughput testing whether this is an issue and consider changes then
 
-		CacheableSqmInterpretation localCopy = cacheableSqmInterpretation;
+		CacheableSqmInterpretation<SelectStatement, JdbcOperationQuerySelect> localCopy = cacheableSqmInterpretation;
 		JdbcParameterBindings jdbcParameterBindings = null;
 
 		executionContext.getSession().autoPreFlush();
@@ -410,23 +410,23 @@ private <T, X> T withCacheableSqmInterpretation(DomainQueryExecutionContext exec
 			synchronized ( this ) {
 				localCopy = cacheableSqmInterpretation;
 				if ( localCopy == null ) {
-					localCopy = buildCacheableSqmInterpretation( sqm, domainParameterXref, executionContext );
-					jdbcParameterBindings = localCopy.firstParameterBindings;
-					localCopy.firstParameterBindings = null;
+					final MutableObject<JdbcParameterBindings> mutableValue = new MutableObject<>();
+					localCopy = buildInterpretation( sqm, domainParameterXref, executionContext, mutableValue );
+					jdbcParameterBindings = mutableValue.get();
 					cacheableSqmInterpretation = localCopy;
 				}
 				else {
 					// If the translation depends on parameter bindings or it isn't compatible with the current query options,
 					// we have to rebuild the JdbcSelect, which is still better than having to translate from SQM to SQL AST again
-					if ( localCopy.jdbcSelect.dependsOnParameterBindings() ) {
+					if ( localCopy.jdbcOperation().dependsOnParameterBindings() ) {
 						jdbcParameterBindings = createJdbcParameterBindings( localCopy, executionContext );
 					}
 					// If the translation depends on the limit or lock options, we have to rebuild the JdbcSelect
 					// We could avoid this by putting the lock options into the cache key
-					if ( !localCopy.jdbcSelect.isCompatibleWith( jdbcParameterBindings, executionContext.getQueryOptions() ) ) {
-						localCopy = buildCacheableSqmInterpretation( sqm, domainParameterXref, executionContext );
-						jdbcParameterBindings = localCopy.firstParameterBindings;
-						localCopy.firstParameterBindings = null;
+					if ( !localCopy.jdbcOperation().isCompatibleWith( jdbcParameterBindings, executionContext.getQueryOptions() ) ) {
+						final MutableObject<JdbcParameterBindings> mutableValue = new MutableObject<>();
+						localCopy = buildInterpretation( sqm, domainParameterXref, executionContext, mutableValue );
+						jdbcParameterBindings = mutableValue.get();
 						cacheableSqmInterpretation = localCopy;
 					}
 				}
@@ -435,15 +435,15 @@ private <T, X> T withCacheableSqmInterpretation(DomainQueryExecutionContext exec
 		else {
 			// If the translation depends on parameter bindings or it isn't compatible with the current query options,
 			// we have to rebuild the JdbcSelect, which is still better than having to translate from SQM to SQL AST again
-			if ( localCopy.jdbcSelect.dependsOnParameterBindings() ) {
+			if ( localCopy.jdbcOperation().dependsOnParameterBindings() ) {
 				jdbcParameterBindings = createJdbcParameterBindings( localCopy, executionContext );
 			}
 			// If the translation depends on the limit or lock options, we have to rebuild the JdbcSelect
 			// We could avoid this by putting the lock options into the cache key
-			if ( !localCopy.jdbcSelect.isCompatibleWith( jdbcParameterBindings, executionContext.getQueryOptions() ) ) {
-				localCopy = buildCacheableSqmInterpretation( sqm, domainParameterXref, executionContext );
-				jdbcParameterBindings = localCopy.firstParameterBindings;
-				localCopy.firstParameterBindings = null;
+			if ( !localCopy.jdbcOperation().isCompatibleWith( jdbcParameterBindings, executionContext.getQueryOptions() ) ) {
+				final MutableObject<JdbcParameterBindings> mutableValue = new MutableObject<>();
+				localCopy = buildInterpretation( sqm, domainParameterXref, executionContext, mutableValue );
+				jdbcParameterBindings = mutableValue.get();
 				cacheableSqmInterpretation = localCopy;
 			}
 		}
@@ -455,26 +455,27 @@ private <T, X> T withCacheableSqmInterpretation(DomainQueryExecutionContext exec
 		return interpreter.interpret( context, executionContext, localCopy, jdbcParameterBindings );
 	}
 
-	private JdbcParameterBindings createJdbcParameterBindings(CacheableSqmInterpretation sqmInterpretation, DomainQueryExecutionContext executionContext) {
+	private JdbcParameterBindings createJdbcParameterBindings(CacheableSqmInterpretation<SelectStatement, JdbcOperationQuerySelect> sqmInterpretation, DomainQueryExecutionContext executionContext) {
 		return SqmUtil.createJdbcParameterBindings(
 				executionContext.getQueryParameterBindings(),
 				domainParameterXref,
-				sqmInterpretation.getJdbcParamsXref(),
+				sqmInterpretation.jdbcParamsXref(),
 				new SqmParameterMappingModelResolutionAccess() {
 					//this is pretty ugly!
 					@Override @SuppressWarnings("unchecked")
 					public <T> MappingModelExpressible<T> getResolvedMappingModelType(SqmParameter<T> parameter) {
-						return (MappingModelExpressible<T>) sqmInterpretation.getSqmParameterMappingModelTypes().get(parameter);
+						return (MappingModelExpressible<T>) sqmInterpretation.sqmParameterMappingModelTypes().get(parameter);
 					}
 				},
 				executionContext.getSession()
 		);
 	}
 
-	private static CacheableSqmInterpretation buildCacheableSqmInterpretation(
+	private static CacheableSqmInterpretation<SelectStatement, JdbcOperationQuerySelect> buildInterpretation(
 			SqmSelectStatement<?> sqm,
 			DomainParameterXref domainParameterXref,
-			DomainQueryExecutionContext executionContext) {
+			DomainQueryExecutionContext executionContext,
+			MutableObject<JdbcParameterBindings> firstJdbcParameterBindingsConsumer) {
 		final SharedSessionContractImplementor session = executionContext.getSession();
 		final SessionFactoryImplementor sessionFactory = session.getFactory();
 
@@ -511,57 +512,23 @@ public <T> MappingModelExpressible<T> getResolvedMappingModelType(SqmParameter<T
 				},
 				session
 		);
-
-		return new CacheableSqmInterpretation(
+		firstJdbcParameterBindingsConsumer.set( jdbcParameterBindings );
+		return new CacheableSqmInterpretation<>(
 				sqmInterpretation.getSqlAst(),
 				selectTranslator.translate( jdbcParameterBindings, executionContext.getQueryOptions() ),
 				jdbcParamsXref,
-				sqmInterpretation.getSqmParameterMappingModelTypeResolutions(),
-				jdbcParameterBindings
+				sqmInterpretation.getSqmParameterMappingModelTypeResolutions()
 		);
 	}
 
 	private interface SqmInterpreter<T, X> {
 		T interpret(
 				X context,
 				DomainQueryExecutionContext executionContext,
-				CacheableSqmInterpretation sqmInterpretation,
+				CacheableSqmInterpretation<SelectStatement, JdbcOperationQuerySelect> sqmInterpretation,
 				JdbcParameterBindings jdbcParameterBindings);
 	}
 
-	private static class CacheableSqmInterpretation {
-		private final SelectStatement selectStatement;
-		private final JdbcOperationQuerySelect jdbcSelect;
-		private final Map<QueryParameterImplementor<?>, Map<SqmParameter<?>, List<JdbcParametersList>>> jdbcParamsXref;
-		private final Map<SqmParameter<?>, MappingModelExpressible<?>> sqmParameterMappingModelTypes;
-		private transient JdbcParameterBindings firstParameterBindings;
-
-		CacheableSqmInterpretation(
-				SelectStatement selectStatement,
-				JdbcOperationQuerySelect jdbcSelect,
-				Map<QueryParameterImplementor<?>, Map<SqmParameter<?>, List<JdbcParametersList>>> jdbcParamsXref,
-				Map<SqmParameter<?>, MappingModelExpressible<?>> sqmParameterMappingModelTypes,
-				JdbcParameterBindings firstParameterBindings) {
-			this.selectStatement = selectStatement;
-			this.jdbcSelect = jdbcSelect;
-			this.jdbcParamsXref = jdbcParamsXref;
-			this.sqmParameterMappingModelTypes = sqmParameterMappingModelTypes;
-			this.firstParameterBindings = firstParameterBindings;
-		}
-
-		JdbcOperationQuerySelect getJdbcSelect() {
-			return jdbcSelect;
-		}
-
-		Map<QueryParameterImplementor<?>, Map<SqmParameter<?>, List<JdbcParametersList>>> getJdbcParamsXref() {
-			return jdbcParamsXref;
-		}
-
-		public Map<SqmParameter<?>, MappingModelExpressible<?>> getSqmParameterMappingModelTypes() {
-			return sqmParameterMappingModelTypes;
-		}
-	}
-
 	private static class MySqmJdbcExecutionContextAdapter extends SqmJdbcExecutionContextAdapter {
 		private final SubselectFetch.RegistrationHandler subSelectFetchKeyHandler;
 		private final String hql;