HHH-18860 Store SelectableMapping in ColumnWriteFragment to allow precise parameter casts

Author: beikov

hibernate-core/src/main/java/org/hibernate/metamodel/mapping/SelectableConsumer.java

@@ -4,6 +4,9 @@
  */
 package org.hibernate.metamodel.mapping;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.hibernate.engine.jdbc.Size;
+
 import java.util.function.BiConsumer;
 import java.util.function.IntFunction;
 
@@ -25,7 +28,7 @@ public interface SelectableConsumer {
 
 	/**
 	 * Simple form of visitation over a number of columns by name, using
-	 * a separate {@link SelectableMappings} as a base for additional details.
+	 * a separate {@link JdbcMappingContainer} as a base for additional details.
 	 * <p>
 	 * Intended for use in visiting table keys, where we know JdbcMappings, etc.
 	 * from the identifier.
@@ -44,6 +47,144 @@ default void accept(String tableName, JdbcMappingContainer base, String[] column
 		mutableSelectableMapping.forEach( this::accept );
 	}
 
+	/**
+	 * Simple form of visitation over a number of columns by name, using
+	 * a separate {@link SelectableMappings} as a base for additional details.
+	 * <p>
+	 * Intended for use in visiting table keys, where we know JdbcMappings, etc.
+	 * from the identifier.
+	 * <p>
+	 * The expectation here is for the following details to be available:<ul>
+	 *     <li>{@link SelectableMapping#getContainingTableExpression()}</li>
+	 *     <li>{@link SelectableMapping#getSelectionExpression()} (the column name)</li>
+	 *     <li>{@link SelectableMapping#getWriteExpression()}</li>
+	 *     <li>{@link SelectableMapping#getJdbcMapping()}</li>
+	 * </ul>
+	 */
+	default void accept(SelectableMappings base, String tableName, String[] columnNames) {
+		class SelectableMappingIterator implements SelectableMapping {
+			private final String tableName;
+			private final SelectableMappings delegate;
+			private final String[] columnNames;
+
+			private int index;
+
+			public SelectableMappingIterator(String tableName, SelectableMappings delegate, String[] columnNames) {
+				this.tableName = tableName;
+				this.delegate = delegate;
+				this.columnNames = columnNames;
+				assert delegate.getJdbcTypeCount() == columnNames.length;
+			}
+
+			private void forEach(BiConsumer<Integer,SelectableMapping> consumer) {
+				for ( index = 0; index < columnNames.length; index++ ) {
+					consumer.accept( index, this );
+				}
+			}
+
+			@Override
+			public String getContainingTableExpression() {
+				return tableName;
+			}
+
+			@Override
+			public String getSelectionExpression() {
+				return columnNames[index];
+			}
+
+			@Override
+			public @Nullable String getCustomReadExpression() {
+				return null;
+			}
+
+			@Override
+			public @Nullable String getCustomWriteExpression() {
+				return null;
+			}
+
+			private SelectableMapping getDelegate() {
+				return delegate.getSelectable( index );
+			}
+
+			@Override
+			public String getSelectableName() {
+				return getDelegate().getSelectableName();
+			}
+
+			@Override
+			public SelectablePath getSelectablePath() {
+				return getDelegate().getSelectablePath();
+			}
+
+			@Override
+			public boolean isFormula() {
+				return getDelegate().isFormula();
+			}
+
+			@Override
+			public boolean isNullable() {
+				return getDelegate().isNullable();
+			}
+
+			@Override
+			public boolean isInsertable() {
+				return getDelegate().isInsertable();
+			}
+
+			@Override
+			public boolean isUpdateable() {
+				return getDelegate().isUpdateable();
+			}
+
+			@Override
+			public boolean isPartitioned() {
+				return getDelegate().isPartitioned();
+			}
+
+			@Override
+			public @Nullable String getColumnDefinition() {
+				return getDelegate().getColumnDefinition();
+			}
+
+			@Override
+			public @Nullable Long getLength() {
+				return getDelegate().getLength();
+			}
+
+			@Override
+			public @Nullable Integer getPrecision() {
+				return getDelegate().getPrecision();
+			}
+
+			@Override
+			public @Nullable Integer getScale() {
+				return getDelegate().getScale();
+			}
+
+			@Override
+			public @Nullable Integer getTemporalPrecision() {
+				return getDelegate().getTemporalPrecision();
+			}
+
+			@Override
+			public boolean isLob() {
+				return getDelegate().isLob();
+			}
+
+			@Override
+			public JdbcMapping getJdbcMapping() {
+				return getDelegate().getJdbcMapping();
+			}
+
+			@Override
+			public Size toSize() {
+				return getDelegate().toSize();
+			}
+		}
+
+		final SelectableMappingIterator mutableSelectableMapping = new SelectableMappingIterator( tableName, base, columnNames );
+		mutableSelectableMapping.forEach( this::accept );
+	}
 
 	class MutableSelectableMapping implements SelectableMapping {
 		private final String tableName;

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

@@ -25,8 +25,8 @@ public class SelectableMappingImpl extends SqlTypedMappingImpl implements Select
 	private final String containingTableExpression;
 	private final String selectionExpression;
 	private final SelectablePath selectablePath;
-	private final String customReadExpression;
-	private final String customWriteExpression;
+	private final @Nullable String customReadExpression;
+	private final @Nullable String customWriteExpression;
 	private final boolean isLob;
 	private final boolean nullable;
 	private final boolean insertable;
@@ -37,14 +37,14 @@ public class SelectableMappingImpl extends SqlTypedMappingImpl implements Select
 	public SelectableMappingImpl(
 			String containingTableExpression,
 			String selectionExpression,
-			SelectablePath selectablePath,
-			String customReadExpression,
-			String customWriteExpression,
-			String columnDefinition,
-			Long length,
-			Integer precision,
-			Integer scale,
-			Integer temporalPrecision,
+			@Nullable SelectablePath selectablePath,
+			@Nullable String customReadExpression,
+			@Nullable String customWriteExpression,
+			@Nullable String columnDefinition,
+			@Nullable Long length,
+			@Nullable Integer precision,
+			@Nullable Integer scale,
+			@Nullable Integer temporalPrecision,
 			boolean isLob,
 			boolean nullable,
 			boolean insertable,
@@ -55,7 +55,7 @@ public SelectableMappingImpl(
 		super( columnDefinition, length, precision, scale, temporalPrecision, jdbcMapping );
 		assert selectionExpression != null;
 		// Save memory by using interned strings. Probability is high that we have multiple duplicate strings
-		this.containingTableExpression = containingTableExpression == null ? null : containingTableExpression.intern();
+		this.containingTableExpression = containingTableExpression.intern();
 		this.selectionExpression = selectionExpression.intern();
 		this.selectablePath = selectablePath == null ? new SelectablePath( selectionExpression ) : selectablePath;
 		this.customReadExpression = customReadExpression == null ? null : customReadExpression.intern();
@@ -241,7 +241,7 @@ public String getSelectionExpression() {
 
 	@Override
 	public String getSelectableName() {
-		return selectablePath == null ? null : selectablePath.getSelectableName();
+		return selectablePath.getSelectableName();
 	}
 
 	@Override
@@ -250,17 +250,12 @@ public SelectablePath getSelectablePath() {
 	}
 
 	@Override
-	public String getCustomReadExpression() {
+	public @Nullable String getCustomReadExpression() {
 		return customReadExpression;
 	}
 
 	@Override
-	public String getCustomWriteExpression() {
-		return customWriteExpression;
-	}
-
-	@Override
-	public String getWriteExpression() {
+	public @Nullable String getCustomWriteExpression() {
 		return customWriteExpression;
 	}
 

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

@@ -214,41 +214,19 @@ public Predicate createNonDeletedRestriction(TableReference tableReference, SqlE
 
 	@Override
 	public ColumnValueBinding createNonDeletedValueBinding(ColumnReference softDeleteColumnReference) {
-		final ColumnWriteFragment nonDeletedFragment;
-		if ( strategy == SoftDeleteType.TIMESTAMP ) {
-			nonDeletedFragment = new ColumnWriteFragment(
-					null,
-					Collections.emptyList(),
-					jdbcMapping
-			);
-		}
-		else {
-			nonDeletedFragment = new ColumnWriteFragment(
-					nonDeletedLiteralText,
-					Collections.emptyList(),
-					jdbcMapping
-			);
-		}
+		final var nonDeletedFragment =
+				strategy == SoftDeleteType.TIMESTAMP
+						? new ColumnWriteFragment( null, Collections.emptyList(), this )
+						: new ColumnWriteFragment( nonDeletedLiteralText, Collections.emptyList(), this );
 		return new ColumnValueBinding( softDeleteColumnReference, nonDeletedFragment );
 	}
 
 	@Override
 	public ColumnValueBinding createDeletedValueBinding(ColumnReference softDeleteColumnReference) {
-		final ColumnWriteFragment deletedFragment;
-		if ( strategy == SoftDeleteType.TIMESTAMP ) {
-			deletedFragment = new ColumnWriteFragment(
-					currentTimestampFunctionName,
-					Collections.emptyList(),
-					getJdbcMapping()
-			);
-		}
-		else {
-			deletedFragment = new ColumnWriteFragment(
-					deletedLiteralText,
-					Collections.emptyList(),
-					jdbcMapping
-			);
-		}
+		final ColumnWriteFragment deletedFragment =
+				strategy == SoftDeleteType.TIMESTAMP
+						? new ColumnWriteFragment( currentTimestampFunctionName, Collections.emptyList(), this )
+						: new ColumnWriteFragment( deletedLiteralText, Collections.emptyList(), this );
 		return new ColumnValueBinding( softDeleteColumnReference, deletedFragment );
 	}
 

hibernate-core/src/main/java/org/hibernate/persister/collection/AbstractCollectionPersister.java

@@ -98,7 +98,6 @@
 import org.hibernate.sql.ast.spi.SqlAstCreationState;
 import org.hibernate.sql.ast.spi.SqlSelection;
 import org.hibernate.sql.ast.tree.expression.AliasedExpression;
-import org.hibernate.sql.ast.tree.expression.ColumnReference;
 import org.hibernate.sql.ast.tree.from.TableGroup;
 import org.hibernate.sql.ast.tree.from.TableReference;
 import org.hibernate.sql.ast.tree.predicate.Predicate;
@@ -109,7 +108,6 @@
 import org.hibernate.sql.model.TableMapping;
 import org.hibernate.sql.model.TableMapping.MutationDetails;
 import org.hibernate.sql.model.ast.ColumnValueBinding;
-import org.hibernate.sql.model.ast.ColumnValueParameter;
 import org.hibernate.sql.model.ast.ColumnValueParameterList;
 import org.hibernate.sql.model.ast.ColumnWriteFragment;
 import org.hibernate.sql.model.ast.MutatingTableReference;
@@ -134,6 +132,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
@@ -1753,7 +1752,7 @@ public RestrictedTableMutation<JdbcMutationOperation> generateDeleteAllAst(Mutat
 		final ColumnValueParameterList parameterBinders =
 				new ColumnValueParameterList( tableReference, ParameterUsage.RESTRICT, keyColumnCount );
 		final java.util.List<ColumnValueBinding> restrictionBindings = arrayList( keyColumnCount );
-		applyKeyRestrictions( tableReference, parameterBinders, restrictionBindings );
+		applyKeyRestrictions( parameterBinders, restrictionBindings );
 
 		//noinspection unchecked,rawtypes
 		return (RestrictedTableMutation) new TableDeleteStandard(
@@ -1768,27 +1767,24 @@ public RestrictedTableMutation<JdbcMutationOperation> generateDeleteAllAst(Mutat
 	}
 
 	protected void applyKeyRestrictions(
-			MutatingTableReference tableReference,
 			ColumnValueParameterList parameterList,
-			java.util.List<ColumnValueBinding> restrictionBindings) {
-
-		final ForeignKeyDescriptor fkDescriptor = getAttributeMapping().getKeyDescriptor();
-		assert fkDescriptor != null;
-
-		fkDescriptor.getKeyPart().forEachSelectable( parameterList );
-		for ( ColumnValueParameter columnValueParameter : parameterList ) {
-			final ColumnReference columnReference = columnValueParameter.getColumnReference();
+			List<ColumnValueBinding> restrictionBindings) {
+		final var foreignKeyDescriptor = getAttributeMapping().getKeyDescriptor();
+		assert foreignKeyDescriptor != null;
+		foreignKeyDescriptor.getKeyPart().forEachSelectable( (selectionIndex, selectableMapping) -> {
+			final var columnValueParameter = parameterList.addColumValueParameter( selectableMapping );
+			final var columnReference = columnValueParameter.getColumnReference();
 			restrictionBindings.add(
 					new ColumnValueBinding(
 							columnReference,
 							new ColumnWriteFragment(
 									"?",
 									columnValueParameter,
-									columnReference.getJdbcMapping()
+									selectableMapping
 							)
 					)
 			);
-		}
+		});
 	}
 
 

hibernate-core/src/main/java/org/hibernate/persister/collection/BasicCollectionPersister.java

@@ -217,7 +217,7 @@ public RestrictedTableMutation<JdbcMutationOperation> generateDeleteAllAst(Mutat
 				keyColumnCount
 		);
 		final java.util.List<ColumnValueBinding> restrictionBindings = arrayList( keyColumnCount );
-		applyKeyRestrictions( tableReference, parameterBinders, restrictionBindings );
+		applyKeyRestrictions( parameterBinders, restrictionBindings );
 
 		final ColumnReference softDeleteColumn = new ColumnReference( tableReference, softDeleteMapping );
 		final ColumnValueBinding nonDeletedBinding = softDeleteMapping.createNonDeletedValueBinding( softDeleteColumn );