mninor code style changes around Operations stuff

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

@@ -124,9 +124,12 @@ public SoftDeleteMappingImpl(
 		}
 		else {
 			//noinspection unchecked
-			final BasicValueConverter<Boolean, Object> converter = (BasicValueConverter<Boolean, Object>) resolution.getValueConverter();
+			final BasicValueConverter<Boolean, ?> converter =
+					(BasicValueConverter<Boolean, ?>)
+							resolution.getValueConverter();
 			//noinspection unchecked
-			final JdbcLiteralFormatter<Object> literalFormatter = resolution.getJdbcMapping().getJdbcLiteralFormatter();
+			final JdbcLiteralFormatter<Object> literalFormatter =
+					resolution.getJdbcMapping().getJdbcLiteralFormatter();
 
 			if ( converter == null ) {
 				// the database column is BIT or BOOLEAN : pass-thru
@@ -175,16 +178,10 @@ public Object getDeletionIndicator() {
 	@Override
 	public Assignment createSoftDeleteAssignment(TableReference tableReference) {
 		final ColumnReference columnReference = new ColumnReference( tableReference, this );
-		final Expression valueExpression;
-
-		if ( strategy == SoftDeleteType.TIMESTAMP ) {
-			valueExpression = currentTimestampFunctionExpression;
-		}
-		else {
-			//noinspection rawtypes,unchecked
-			valueExpression = new JdbcLiteral( deletedLiteralValue, jdbcMapping );
-		}
-
+		final Expression valueExpression =
+				strategy == SoftDeleteType.TIMESTAMP
+						? currentTimestampFunctionExpression
+						: new JdbcLiteral<>( deletedLiteralValue, jdbcMapping );
 		return new Assignment( columnReference, valueExpression );
 	}
 

hibernate-core/src/main/java/org/hibernate/sql/ast/tree/expression/JdbcLiteral.java

@@ -16,7 +16,6 @@
 import org.hibernate.query.sqm.sql.internal.DomainResultProducer;
 import org.hibernate.sql.ast.SqlAstWalker;
 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.exec.spi.ExecutionContext;
 import org.hibernate.sql.exec.spi.JdbcParameterBindings;
@@ -79,7 +78,7 @@ public void bindParameterValue(
 	// MappingModelExpressible
 
 	@Override
-	public MappingModelExpressible getExpressionType() {
+	public MappingModelExpressible<?> getExpressionType() {
 		return this;
 	}
 
@@ -114,14 +113,20 @@ public Object disassemble(Object value, SharedSessionContractImplementor session
 
 	@Override
 	public void addToCacheKey(MutableCacheKeyBuilder cacheKey, Object value, SharedSessionContractImplementor session) {
-		if ( value == null ) {
-			return;
+		if ( value != null ) {
+			cacheKey.addValue( disassemble( value, jdbcMapping.getJdbcJavaType().getMutabilityPlan(), session ) );
+			cacheKey.addHashCode( hashCode( value, jdbcMapping.getJavaTypeDescriptor() ) );
 		}
-		final Serializable disassemble = ( (MutabilityPlan<Object>) jdbcMapping.getJdbcJavaType().getMutabilityPlan() )
-				.disassemble( value, session );
-		final int hashCode = jdbcMapping.getJavaTypeDescriptor().extractHashCode( value );
-		cacheKey.addValue( disassemble );
-		cacheKey.addHashCode( hashCode );
+	}
+
+	private static <T> int hashCode(Object value, JavaType<T> javaTypeDescriptor) {
+		return javaTypeDescriptor.extractHashCode( (T) value );
+	}
+
+	private static <T> Serializable disassemble(
+			Object value, MutabilityPlan<T> mutabilityPlan,
+			SharedSessionContractImplementor session) {
+		return mutabilityPlan.disassemble( (T) value, session );
 	}
 
 	@Override
@@ -155,28 +160,25 @@ public <X, Y> int forEachJdbcValue(
 	@Override
 	public DomainResult<T> createDomainResult(String resultVariable, DomainResultCreationState creationState) {
 		final SqlAstCreationState sqlAstCreationState = creationState.getSqlAstCreationState();
-		final SqlExpressionResolver sqlExpressionResolver = sqlAstCreationState.getSqlExpressionResolver();
-
-		final SqlSelection sqlSelection = sqlExpressionResolver.resolveSqlSelection(
-				this,
-				jdbcMapping.getJdbcJavaType(),
-				null,
-				sqlAstCreationState.getCreationContext().getMappingMetamodel().getTypeConfiguration()
-		);
-
+		final SqlSelection sqlSelection =
+				sqlAstCreationState.getSqlExpressionResolver()
+						.resolveSqlSelection(
+								this,
+								jdbcMapping.getJdbcJavaType(),
+								null,
+								sqlAstCreationState.getCreationContext().getTypeConfiguration()
+						);
 		return new BasicResult<>( sqlSelection.getValuesArrayPosition(), resultVariable, jdbcMapping );
 	}
 
 	@Override
 	public void applySqlSelections(DomainResultCreationState creationState) {
 		final SqlAstCreationState sqlAstCreationState = creationState.getSqlAstCreationState();
-		final SqlExpressionResolver sqlExpressionResolver = sqlAstCreationState.getSqlExpressionResolver();
-
-		sqlExpressionResolver.resolveSqlSelection(
+		sqlAstCreationState.getSqlExpressionResolver().resolveSqlSelection(
 				this,
 				jdbcMapping.getJdbcJavaType(),
 				null,
-				sqlAstCreationState.getCreationContext().getMappingMetamodel().getTypeConfiguration()
+				sqlAstCreationState.getCreationContext().getTypeConfiguration()
 		);
 	}
 

hibernate-core/src/main/java/org/hibernate/sql/exec/spi/AbstractJdbcOperationQuery.java

@@ -4,14 +4,15 @@
  */
 package org.hibernate.sql.exec.spi;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import org.hibernate.query.spi.QueryOptions;
 import org.hibernate.sql.ast.tree.expression.JdbcParameter;
 
+import static java.util.Collections.emptyMap;
+
 /**
  * Executable JDBC command
  *
@@ -27,12 +28,7 @@ public AbstractJdbcOperationQuery(
 			String sql,
 			List<JdbcParameterBinder> parameterBinders,
 			Set<String> affectedTableNames) {
-		this(
-				sql,
-				parameterBinders,
-				affectedTableNames,
-				Collections.emptyMap()
-		);
+		this( sql, parameterBinders, affectedTableNames, emptyMap() );
 	}
 
 	public AbstractJdbcOperationQuery(
@@ -77,7 +73,7 @@ public boolean isCompatibleWith(JdbcParameterBindings jdbcParameterBindings, Que
 			if ( jdbcParameterBindings == null ) {
 				return false;
 			}
-			for ( Map.Entry<JdbcParameter, JdbcParameterBinding> entry : appliedParameters.entrySet() ) {
+			for ( var entry : appliedParameters.entrySet() ) {
 				final JdbcParameterBinding binding = jdbcParameterBindings.getBinding( entry.getKey() );
 				final JdbcParameterBinding appliedBinding = entry.getValue();
 				//noinspection unchecked

hibernate-core/src/main/java/org/hibernate/sql/exec/spi/JdbcOperationQuerySelect.java

@@ -44,7 +44,7 @@ public JdbcOperationQuerySelect(
 				JdbcLockStrategy.AUTO,
 				null,
 				null
-				);
+		);
 	}
 
 	public JdbcOperationQuerySelect(
@@ -101,7 +101,7 @@ public boolean isCompatibleWith(JdbcParameterBindings jdbcParameterBindings, Que
 			if ( jdbcParameterBindings == null ) {
 				return false;
 			}
-			for ( Map.Entry<JdbcParameter, JdbcParameterBinding> entry : appliedParameters.entrySet() ) {
+			for ( var entry : appliedParameters.entrySet() ) {
 				final JdbcParameter parameter = entry.getKey();
 				final JdbcParameterBinding appliedBinding = entry.getValue();
 				// This is a special case where the rendered SQL depends on the presence of the parameter,

hibernate-core/src/main/java/org/hibernate/sql/model/jdbc/DeleteOrUpsertOperation.java

@@ -6,32 +6,28 @@
 
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
-import java.util.Collections;
-import java.util.List;
 import java.util.Locale;
-import java.util.Set;
 
 import org.hibernate.engine.jdbc.mutation.JdbcValueBindings;
 import org.hibernate.engine.jdbc.mutation.ParameterUsage;
 import org.hibernate.engine.jdbc.mutation.group.PreparedStatementDetails;
 import org.hibernate.engine.jdbc.mutation.internal.MutationQueryOptions;
 import org.hibernate.engine.jdbc.mutation.internal.PreparedStatementGroupSingleTable;
 import org.hibernate.engine.jdbc.mutation.spi.Binding;
-import org.hibernate.engine.jdbc.mutation.spi.BindingGroup;
+import org.hibernate.engine.jdbc.spi.JdbcServices;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.persister.entity.mutation.EntityMutationTarget;
 import org.hibernate.persister.entity.mutation.EntityTableMapping;
 import org.hibernate.persister.entity.mutation.UpdateValuesAnalysis;
-import org.hibernate.sql.ast.SqlAstTranslator;
 import org.hibernate.sql.model.MutationTarget;
 import org.hibernate.sql.model.MutationType;
 import org.hibernate.sql.model.SelfExecutingUpdateOperation;
 import org.hibernate.sql.model.TableMapping;
 import org.hibernate.sql.model.ValuesAnalysis;
-import org.hibernate.sql.model.ast.ColumnValueParameter;
 import org.hibernate.sql.model.internal.OptionalTableUpdate;
 import org.hibernate.sql.model.internal.TableDeleteStandard;
 
+import static java.util.Collections.emptyList;
 import static org.hibernate.sql.model.ModelMutationLogging.MODEL_MUTATION_LOGGER;
 
 /**
@@ -92,12 +88,12 @@ public void performMutation(
 			SharedSessionContractImplementor session) {
 		final UpdateValuesAnalysis analysis = (UpdateValuesAnalysis) valuesAnalysis;
 
-		if ( !analysis.getTablesWithNonNullValues().contains( tableMapping ) ) {
-			// all the new values are null - delete
-			performDelete( jdbcValueBindings, session );
+		if ( analysis.getTablesWithNonNullValues().contains( tableMapping ) ) {
+			performUpsert( jdbcValueBindings, session );
 		}
 		else {
-			performUpsert( jdbcValueBindings, session );
+			// all the new values are null - delete
+			performDelete( jdbcValueBindings, session );
 		}
 	}
 
@@ -109,31 +105,21 @@ private void performDelete(JdbcValueBindings jdbcValueBindings, SharedSessionCon
 				mutationTarget,
 				"upsert delete",
 				optionalTableUpdate.getKeyBindings(),
-				Collections.emptyList(),
-				Collections.emptyList()
+				emptyList(),
+				emptyList()
 		);
 
-		final SqlAstTranslator<JdbcDeleteMutation> translator = session
-				.getJdbcServices()
-				.getJdbcEnvironment()
-				.getSqlAstTranslatorFactory()
-				.buildModelMutationTranslator( upsertDeleteAst, session.getFactory() );
-		final JdbcDeleteMutation upsertDelete = translator.translate( null, MutationQueryOptions.INSTANCE );
-
-		final PreparedStatementGroupSingleTable statementGroup = new PreparedStatementGroupSingleTable( upsertDelete, session );
-		final PreparedStatementDetails statementDetails = statementGroup.resolvePreparedStatementDetails( tableMapping.getTableName() );
-
+		final JdbcServices jdbcServices = session.getJdbcServices();
+		final var upsertDelete =
+				jdbcServices.getJdbcEnvironment().getSqlAstTranslatorFactory()
+						.buildModelMutationTranslator( upsertDeleteAst, session.getFactory() )
+						.translate( null, MutationQueryOptions.INSTANCE );
+		final var statementGroup = new PreparedStatementGroupSingleTable( upsertDelete, session );
+		final var statementDetails = statementGroup.resolvePreparedStatementDetails( tableMapping.getTableName() );
 		try {
 			final PreparedStatement upsertDeleteStatement = statementDetails.resolveStatement();
-			session.getJdbcServices().getSqlStatementLogger().logStatement( statementDetails.getSqlString() );
-
-			bindDeleteKeyValues(
-					jdbcValueBindings,
-					optionalTableUpdate.getParameters(),
-					statementDetails,
-					session
-			);
-
+			jdbcServices.getSqlStatementLogger().logStatement( statementDetails.getSqlString() );
+			bindDeleteKeyValues( jdbcValueBindings, statementDetails, session );
 			final int rowCount = session.getJdbcCoordinator().getResultSetReturn()
 					.executeUpdate( upsertDeleteStatement, statementDetails.getSqlString() );
 			MODEL_MUTATION_LOGGER.tracef( "`%s` rows upsert-deleted from `%s`", rowCount, tableMapping.getTableName() );
@@ -145,29 +131,22 @@ private void performDelete(JdbcValueBindings jdbcValueBindings, SharedSessionCon
 
 	private void bindDeleteKeyValues(
 			JdbcValueBindings jdbcValueBindings,
-			List<ColumnValueParameter> parameters,
 			PreparedStatementDetails statementDetails,
 			SharedSessionContractImplementor session) {
 		final PreparedStatement statement = statementDetails.resolveStatement();
-
-		final BindingGroup bindingGroup = jdbcValueBindings.getBindingGroup( tableMapping.getTableName() );
-		final Set<Binding> bindings = bindingGroup.getBindings();
-
 		int jdbcBindingPosition = 1;
-		for ( Binding binding : bindings ) {
-			if ( binding.getValueDescriptor().getUsage() != ParameterUsage.RESTRICT ) {
-				continue;
+		for ( Binding binding : jdbcValueBindings.getBindingGroup( tableMapping.getTableName() ).getBindings() ) {
+			if ( binding.getValueDescriptor().getUsage() == ParameterUsage.RESTRICT ) {
+				bindKeyValue(
+						jdbcBindingPosition++,
+						binding,
+						binding.getValueDescriptor(),
+						statement,
+						statementDetails.getSqlString(),
+						tableMapping,
+						session
+				);
 			}
-
-			bindKeyValue(
-					jdbcBindingPosition++,
-					binding,
-					binding.getValueDescriptor(),
-					statement,
-					statementDetails.getSqlString(),
-					tableMapping,
-					session
-			);
 		}
 	}
 
@@ -199,18 +178,15 @@ private static void bindKeyValue(
 	private void performUpsert(JdbcValueBindings jdbcValueBindings, SharedSessionContractImplementor session) {
 		MODEL_MUTATION_LOGGER.tracef( "#performUpsert(%s)", tableMapping.getTableName() );
 
-		final PreparedStatementGroupSingleTable statementGroup = new PreparedStatementGroupSingleTable( upsertOperation, session );
-		final PreparedStatementDetails statementDetails = statementGroup.resolvePreparedStatementDetails( tableMapping.getTableName() );
-
+		final var statementGroup = new PreparedStatementGroupSingleTable( upsertOperation, session );
+		final var statementDetails = statementGroup.resolvePreparedStatementDetails( tableMapping.getTableName() );
 		try {
 			final PreparedStatement updateStatement = statementDetails.resolveStatement();
 			session.getJdbcServices().getSqlStatementLogger().logStatement( statementDetails.getSqlString() );
-
 			jdbcValueBindings.beforeStatement( statementDetails );
-
-			final int rowCount = session.getJdbcCoordinator().getResultSetReturn()
-					.executeUpdate( updateStatement, statementDetails.getSqlString() );
-
+			final int rowCount =
+					session.getJdbcCoordinator().getResultSetReturn()
+							.executeUpdate( updateStatement, statementDetails.getSqlString() );
 			MODEL_MUTATION_LOGGER.tracef( "`%s` rows upserted into `%s`", rowCount, tableMapping.getTableName() );
 		}
 		finally {

hibernate-core/src/main/java/org/hibernate/sql/model/jdbc/OptionalTableUpdateOperation.java

@@ -11,27 +11,23 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
-import java.util.Set;
 
 import org.hibernate.engine.jdbc.mutation.JdbcValueBindings;
 import org.hibernate.engine.jdbc.mutation.ParameterUsage;
-import org.hibernate.engine.jdbc.mutation.group.PreparedStatementDetails;
 import org.hibernate.engine.jdbc.mutation.internal.JdbcValueDescriptorImpl;
 import org.hibernate.engine.jdbc.mutation.internal.MutationQueryOptions;
 import org.hibernate.engine.jdbc.mutation.internal.PreparedStatementGroupSingleTable;
 import org.hibernate.engine.jdbc.mutation.spi.Binding;
 import org.hibernate.engine.jdbc.mutation.spi.BindingGroup;
 import org.hibernate.engine.jdbc.spi.JdbcCoordinator;
-import org.hibernate.engine.jdbc.spi.MutationStatementPreparer;
+import org.hibernate.engine.jdbc.spi.JdbcServices;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.internal.util.collections.CollectionHelper;
 import org.hibernate.jdbc.Expectation;
 import org.hibernate.persister.entity.mutation.EntityMutationTarget;
 import org.hibernate.persister.entity.mutation.EntityTableMapping;
 import org.hibernate.persister.entity.mutation.UpdateValuesAnalysis;
-import org.hibernate.sql.ast.SqlAstTranslator;
-import org.hibernate.sql.ast.SqlAstTranslatorFactory;
 import org.hibernate.sql.model.MutationTarget;
 import org.hibernate.sql.model.MutationType;
 import org.hibernate.sql.model.PreparableMutationOperation;
@@ -86,8 +82,7 @@ public OptionalTableUpdateOperation(
 
 		this.jdbcValueDescriptors = CollectionHelper.arrayList( parameters.size() );
 		for ( int i = 0; i < parameters.size(); i++ ) {
-			final ColumnValueParameter valueParameter = parameters.get( i );
-			jdbcValueDescriptors.add( new JdbcValueDescriptorImpl( valueParameter, i+1 ) );
+			jdbcValueDescriptors.add( new JdbcValueDescriptorImpl( parameters.get( i ), i + 1 ) );
 		}
 	}
 
@@ -125,57 +120,51 @@ public void performMutation(
 			ValuesAnalysis incomingValuesAnalysis,
 			SharedSessionContractImplementor session) {
 		final UpdateValuesAnalysis valuesAnalysis = (UpdateValuesAnalysis) incomingValuesAnalysis;
-		if ( !valuesAnalysis.getTablesNeedingUpdate().contains( tableMapping )
-				&& !valuesAnalysis.getTablesNeedingDynamicUpdate().contains( tableMapping ) ) {
-			return;
-		}
-
-		try {
-			if ( !valuesAnalysis.getTablesWithNonNullValues().contains( tableMapping ) ) {
-				// all the new values for this table were null - possibly delete the row
-				if ( valuesAnalysis.getTablesWithPreviousNonNullValues().contains( tableMapping ) ) {
-					performDelete( jdbcValueBindings, session );
-				}
-			}
-			else {
-				// there are some non-null values for the table - we need to update or insert the values.
-
-				// first, try the update and see if any row was affected
-				final boolean wasUpdated;
-				if ( valuesAnalysis.getTablesWithPreviousNonNullValues().contains( tableMapping ) ) {
-					// either
-					// 		1) not know if the values for this table were previously all null (because old values are not known)
-					//		2) the values for this table were previously had at least one non-null
-					wasUpdated = performUpdate( jdbcValueBindings, session );
+		if ( valuesAnalysis.getTablesNeedingUpdate().contains( tableMapping )
+				|| valuesAnalysis.getTablesNeedingDynamicUpdate().contains( tableMapping ) ) {
+			try {
+				if ( !valuesAnalysis.getTablesWithNonNullValues().contains( tableMapping ) ) {
+					// all the new values for this table were null - possibly delete the row
+					if ( valuesAnalysis.getTablesWithPreviousNonNullValues().contains( tableMapping ) ) {
+						performDelete( jdbcValueBindings, session );
+					}
 				}
 				else {
-					wasUpdated = false;
-				}
+					// there are some non-null values for the table - we need to update or insert the values.
+
+					// first, try the update and see if any row was affected
+					final boolean wasUpdated;
+					if ( valuesAnalysis.getTablesWithPreviousNonNullValues().contains( tableMapping ) ) {
+						// either
+						// 		1) not know if the values for this table were previously all null (because old values are not known)
+						//		2) the values for this table were previously had at least one non-null
+						wasUpdated = performUpdate( jdbcValueBindings, session );
+					}
+					else {
+						wasUpdated = false;
+					}
 
-				if ( !wasUpdated ) {
-					MODEL_MUTATION_LOGGER.debugf(
-							"Upsert update altered no rows - inserting : %s",
-							tableMapping.getTableName()
-					);
-					performInsert( jdbcValueBindings, session );
+					if ( !wasUpdated ) {
+						MODEL_MUTATION_LOGGER.debugf(
+								"Upsert update altered no rows - inserting : %s",
+								tableMapping.getTableName()
+						);
+						performInsert( jdbcValueBindings, session );
+					}
 				}
 			}
+			finally {
+				jdbcValueBindings.afterStatement( tableMapping );
+			}
 		}
-		finally {
-			jdbcValueBindings.afterStatement( tableMapping );
-		}
-
 	}
 
 	private void performDelete(JdbcValueBindings jdbcValueBindings, SharedSessionContractImplementor session) {
 		final JdbcDeleteMutation jdbcDelete = createJdbcDelete( session );
-
 		final JdbcCoordinator jdbcCoordinator = session.getJdbcCoordinator();
 		final PreparedStatement deleteStatement = createStatementDetails( jdbcDelete, jdbcCoordinator );
 		session.getJdbcServices().getSqlStatementLogger().logStatement( jdbcDelete.getSqlString() );
-
 		bindKeyValues( jdbcValueBindings, deleteStatement, jdbcDelete, session );
-
 		try {
 			session.getJdbcCoordinator().getResultSetReturn()
 					.executeUpdate( deleteStatement, jdbcDelete.getSqlString() );
@@ -204,41 +193,34 @@ private void bindKeyValues(
 
 		int jdbcBindingPosition = 1;
 		boolean foundKeyBindings = false;
-
-		final Set<Binding> bindings = bindingGroup.getBindings();
 		// leverage the fact that bindings are contiguous to avoid full nested iterations
 		final Iterator<ColumnValueBinding> keyBindingsItr = keyBindings.iterator();
-
-		bindings: for ( Binding binding : bindings ) {
+		bindings: for ( Binding binding : bindingGroup.getBindings() ) {
 			// binding-position here is 1-based (JDBC)
 			final JdbcValueDescriptor valueDescriptor = jdbcValueDescriptors.get( binding.getPosition() - 1 );
-
 			// key bindings would have a usage of RESTRICT relative to the UPDATE
-			if ( valueDescriptor.getUsage() != ParameterUsage.RESTRICT ) {
-				continue;
-			}
-
-			while ( keyBindingsItr.hasNext() ) {
-				final ColumnValueBinding valueBinding = keyBindingsItr.next();
-
-				if ( Objects.equals( valueBinding.getColumnReference().getColumnExpression(), binding.getColumnName() ) ) {
-					// `binding` is for a key column
-					foundKeyBindings = true;
-					bindKeyValue(
-							jdbcBindingPosition++,
-							binding,
-							valueDescriptor,
-							statement,
-							jdbcDelete.getSqlString(),
-							tableMapping,
-							session
-					);
-					break;
-				}
-				else {
-					if ( foundKeyBindings ) {
-						// we are now "beyond" the key bindings
-						break bindings;
+			if ( valueDescriptor.getUsage() == ParameterUsage.RESTRICT ) {
+				while ( keyBindingsItr.hasNext() ) {
+					if ( Objects.equals( keyBindingsItr.next().getColumnReference().getColumnExpression(),
+							binding.getColumnName() ) ) {
+						// binding is for a key column
+						foundKeyBindings = true;
+						bindKeyValue(
+								jdbcBindingPosition++,
+								binding,
+								valueDescriptor,
+								statement,
+								jdbcDelete.getSqlString(),
+								tableMapping,
+								session
+						);
+						break;
+					}
+					else {
+						if ( foundKeyBindings ) {
+							// we are now "beyond" the key bindings
+							break bindings;
+						}
 					}
 				}
 			}
@@ -298,53 +280,41 @@ protected JdbcDeleteMutation createJdbcDelete(SharedSessionContractImplementor s
 		}
 
 		final SessionFactoryImplementor factory = session.getSessionFactory();
-		final SqlAstTranslatorFactory sqlAstTranslatorFactory = factory
-				.getJdbcServices()
-				.getJdbcEnvironment()
-				.getSqlAstTranslatorFactory();
-
-		final SqlAstTranslator<JdbcDeleteMutation> translator = sqlAstTranslatorFactory.buildModelMutationTranslator(
-				tableDelete,
-				factory
-		);
-
-		return translator.translate( null, MutationQueryOptions.INSTANCE );
+		return factory.getJdbcServices().getJdbcEnvironment().getSqlAstTranslatorFactory()
+				.buildModelMutationTranslator( tableDelete, factory )
+				.translate( null, MutationQueryOptions.INSTANCE );
 	}
 
 	private boolean performUpdate(
 			JdbcValueBindings jdbcValueBindings,
 			SharedSessionContractImplementor session) {
 		MODEL_MUTATION_LOGGER.tracef( "#performUpdate(%s)", tableMapping.getTableName() );
-		final JdbcMutationOperation jdbcUpdate = createJdbcUpdate( session );
-
-		final PreparedStatementGroupSingleTable statementGroup = new PreparedStatementGroupSingleTable( jdbcUpdate, session );
-		final PreparedStatementDetails statementDetails = statementGroup.resolvePreparedStatementDetails( tableMapping.getTableName() );
 
+		final JdbcServices jdbcServices = session.getJdbcServices();
+		final var statementGroup = new PreparedStatementGroupSingleTable( createJdbcUpdate( session ), session );
+		final var statementDetails = statementGroup.resolvePreparedStatementDetails( tableMapping.getTableName() );
 		try {
 			final PreparedStatement updateStatement = statementDetails.resolveStatement();
-
-			session.getJdbcServices().getSqlStatementLogger().logStatement( statementDetails.getSqlString() );
-
+			jdbcServices.getSqlStatementLogger().logStatement( statementDetails.getSqlString() );
 			jdbcValueBindings.beforeStatement( statementDetails );
-
-			final int rowCount = session.getJdbcCoordinator().getResultSetReturn()
-					.executeUpdate( updateStatement, statementDetails.getSqlString() );
-
+			final int rowCount =
+					session.getJdbcCoordinator().getResultSetReturn()
+							.executeUpdate( updateStatement, statementDetails.getSqlString() );
 			if ( rowCount == 0 ) {
 				return false;
 			}
-
-			expectation.verifyOutcome(
-					rowCount,
-					updateStatement,
-					-1,
-					statementDetails.getSqlString()
-			);
-
-			return true;
+			else {
+				expectation.verifyOutcome(
+						rowCount,
+						updateStatement,
+						-1,
+						statementDetails.getSqlString()
+				);
+				return true;
+			}
 		}
 		catch (SQLException e) {
-			throw session.getJdbcServices().getSqlExceptionHelper().convert(
+			throw jdbcServices.getSqlExceptionHelper().convert(
 					e,
 					"Unable to execute mutation PreparedStatement against table `" + tableMapping.getTableName() + "`",
 					statementDetails.getSqlString()
@@ -384,24 +354,18 @@ protected JdbcMutationOperation createJdbcUpdate(SharedSessionContractImplemento
 			);
 		}
 
-		final SqlAstTranslator<JdbcMutationOperation> translator = session
-				.getJdbcServices()
-				.getJdbcEnvironment()
-				.getSqlAstTranslatorFactory()
-				.buildModelMutationTranslator( tableUpdate, session.getFactory() );
-
-		return translator.translate( null, MutationQueryOptions.INSTANCE );
+		return session.getJdbcServices().getJdbcEnvironment().getSqlAstTranslatorFactory()
+				.buildModelMutationTranslator( tableUpdate, session.getFactory() )
+				.translate( null, MutationQueryOptions.INSTANCE );
 	}
 
 	private void performInsert(JdbcValueBindings jdbcValueBindings, SharedSessionContractImplementor session) {
 		final JdbcInsertMutation jdbcInsert = createJdbcInsert( session );
-
+		final JdbcServices jdbcServices = session.getJdbcServices();
 		final JdbcCoordinator jdbcCoordinator = session.getJdbcCoordinator();
 		final PreparedStatement insertStatement = createStatementDetails( jdbcInsert, jdbcCoordinator );
-
 		try {
-			session.getJdbcServices().getSqlStatementLogger().logStatement( jdbcInsert.getSqlString() );
-
+			jdbcServices.getSqlStatementLogger().logStatement( jdbcInsert.getSqlString() );
 			final BindingGroup bindingGroup = jdbcValueBindings.getBindingGroup( tableMapping.getTableName() );
 			if ( bindingGroup != null ) {
 				bindingGroup.forEachBinding( binding -> {
@@ -416,7 +380,7 @@ private void performInsert(JdbcValueBindings jdbcValueBindings, SharedSessionCon
 							);
 						}
 						catch (SQLException e) {
-							throw session.getJdbcServices().getSqlExceptionHelper().convert(
+							throw jdbcServices.getSqlExceptionHelper().convert(
 									e,
 									"Unable to bind parameter for upsert insert",
 									jdbcInsert.getSqlString()
@@ -425,7 +389,6 @@ private void performInsert(JdbcValueBindings jdbcValueBindings, SharedSessionCon
 					}
 				} );
 			}
-
 			jdbcCoordinator.getResultSetReturn()
 					.executeUpdate( insertStatement, jdbcInsert.getSqlString() );
 		}
@@ -460,24 +423,16 @@ protected JdbcInsertMutation createJdbcInsert(SharedSessionContractImplementor s
 		}
 
 		final SessionFactoryImplementor factory = session.getSessionFactory();
-		final SqlAstTranslatorFactory sqlAstTranslatorFactory = factory
-				.getJdbcServices()
-				.getJdbcEnvironment()
-				.getSqlAstTranslatorFactory();
-
-		final SqlAstTranslator<JdbcInsertMutation> translator = sqlAstTranslatorFactory.buildModelMutationTranslator(
-				tableInsert,
-				factory
-		);
-
-		return translator.translate( null, MutationQueryOptions.INSTANCE );
+		return factory.getJdbcServices().getJdbcEnvironment().getSqlAstTranslatorFactory()
+				.buildModelMutationTranslator( tableInsert, factory )
+				.translate( null, MutationQueryOptions.INSTANCE );
 	}
 
 	private static PreparedStatement createStatementDetails(
 			PreparableMutationOperation operation,
 			JdbcCoordinator jdbcCoordinator) {
-		final MutationStatementPreparer statementPreparer = jdbcCoordinator.getMutationStatementPreparer();
-		final PreparedStatement statement = statementPreparer.prepareStatement( operation.getSqlString(), false );
+		final var statementPreparer = jdbcCoordinator.getMutationStatementPreparer();
+		final var statement = statementPreparer.prepareStatement( operation.getSqlString(), false );
 		jdbcCoordinator.getLogicalConnection().getResourceRegistry().register( null, statement );
 		return statement;
 	}