fix most of the unsoundness

Author: gavinking

hibernate-core/src/main/java/org/hibernate/query/internal/QueryParameterBindingImpl.java

@@ -6,6 +6,7 @@
 
 import java.util.Collection;
 
+import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.hibernate.HibernateException;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
@@ -131,27 +132,27 @@ public void setBindValue(Object value, boolean resolveJdbcTypeIfNecessary) {
 	}
 
 	@Override
-	public void setBindValue(Object value, @Nullable BindableType<?> clarifiedType) {
+	public <A> void setBindValue(A value, @Nullable BindableType<A> clarifiedType) {
 		if ( !handleAsMultiValue( value, clarifiedType ) ) {
-			if ( clarifiedType != null ) {
-				// UNSOUND!!!
-				// We should be creating a whole new object
-				bindType = (BindableType<T>) clarifiedType;
-			}
-
 			final Object coerced = coerce( value );
 			validate( coerced );
-			bindValue( coerced );
+			bindValue = cast( value );
+			isBound = true;
+			isMultiValued = false;
+			bindValues = null;
+
+			if ( clarifiedType != null ) {
+				checkClarifiedType( clarifiedType, value );
+				@SuppressWarnings("unchecked") // safe
+				final var newType = (BindableType<T>) clarifiedType;
+				bindType = newType;
+			}
 		}
 	}
 
 	@Override
 	public void setBindValue(Object value, @SuppressWarnings("deprecation") TemporalType temporalTypePrecision) {
 		if ( !handleAsMultiValue( value, null ) ) {
-			if ( bindType == null ) {
-				bindType = queryParameter.getHibernateType();
-			}
-
 			final Object coerced = coerce( value );
 			validate( coerced );
 			bindValue( coerced );
@@ -167,6 +168,8 @@ private void bindValue(Object value) {
 		}
 		bindValue = cast( value );
 		isBound = true;
+		isMultiValued = false;
+		bindValues = null;
 	}
 
 	private void bindNull(boolean resolveJdbcTypeIfNecessary) {
@@ -219,11 +222,9 @@ public void setBindValues(Collection<?> values) {
 		}
 
 		final var coerced = values.stream().map( this::coerce ).toList();
-		values.forEach( this::validate );
-
+		coerced.forEach( this::validate );
 		isBound = true;
 		isMultiValued = true;
-
 		bindValue = null;
 		bindValues = coerced.stream().map( this::cast ).toList();
 
@@ -245,12 +246,26 @@ public void setBindValues(Collection<?> values) {
 	}
 
 	@Override
-	public void setBindValues(Collection<?> values, BindableType<?> clarifiedType) {
+	public <V> void setBindValues(Collection<? extends V> values, BindableType<V> clarifiedType) {
+		if ( !queryParameter.allowsMultiValuedBinding() ) {
+			throw new IllegalArgumentException(
+					"Illegal attempt to bind a collection value to a single-valued parameter"
+			);
+		}
+
+		final var coerced = values.stream().map( this::coerce ).toList();
+		coerced.forEach( this::validate );
+		isBound = true;
+		isMultiValued = true;
+		bindValue = null;
+		bindValues = coerced.stream().map( this::cast ).toList();
+
 		if ( clarifiedType != null ) {
-			// UNSOUND
-			bindType = (BindableType<T>) clarifiedType;
+			checkClarifiedType( clarifiedType, values );
+			@SuppressWarnings("unchecked") // safe
+			final var newType = (BindableType<T>) clarifiedType;
+			bindType = newType;
 		}
-		setBindValues( values );
 	}
 
 	@Override
@@ -300,6 +315,22 @@ else if ( type instanceof BasicValuedMapping basicValuedMapping ) {
 		return false;
 	}
 
+	private <A> void checkClarifiedType(@NonNull BindableType<A> clarifiedType, Object value) {
+		final var parameterType = queryParameter.getParameterType();
+		if ( parameterType != null ) {
+			final var clarifiedJavaType = clarifiedType.getJavaType();
+			if ( !parameterType.isAssignableFrom( clarifiedJavaType ) ) {
+				throw new QueryArgumentException(
+						"Given type is incompatible with parameter type",
+						parameterType, clarifiedJavaType, value
+				);
+			}
+		}
+		else {
+			assert queryParameter.getHibernateType() == null;
+		}
+	}
+
 	private T cast(Object value) {
 		final var bindableType = getCriteriaBuilder().resolveExpressible( bindType );
 		return bindableType == null

hibernate-core/src/main/java/org/hibernate/query/spi/QueryParameterBinding.java

@@ -66,7 +66,7 @@ default void setBindValue(Object value) {
 	 * @param value The bind value
 	 * @param clarifiedType The explicit Type to use
 	 */
-	void setBindValue(Object value, @Nullable BindableType<?> clarifiedType);
+	<A> void setBindValue(A value, @Nullable BindableType<A> clarifiedType);
 
 	/**
 	 * Sets the parameter binding value using the explicit TemporalType.
@@ -95,7 +95,7 @@ default void setBindValue(Object value) {
 	 * @param values The bind values
 	 * @param clarifiedType The explicit Type to use
 	 */
-	void setBindValues(Collection<?> values, BindableType<?> clarifiedType);
+	<A> void setBindValues(Collection<? extends A> values, BindableType<A> clarifiedType);
 
 	/**Sets the parameter binding value using the explicit TemporalType in regards to the individual values.
 	 *

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

@@ -9,6 +9,7 @@
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.query.spi.QueryParameterImplementor;
 import org.hibernate.query.sqm.tree.expression.JpaCriteriaParameter;
+import org.hibernate.query.sqm.tree.expression.SqmParameter;
 import org.hibernate.query.sqm.tree.expression.ValueBindJpaCriteriaParameter;
 import org.hibernate.query.KeyedPage;
 import org.hibernate.query.KeyedResultList;
@@ -142,18 +143,22 @@ protected static void bindValueBindCriteriaParameters(
 			DomainParameterXref domainParameterXref,
 			QueryParameterBindings bindings) {
 		for ( var entry : domainParameterXref.getQueryParameters().entrySet() ) {
-			final var sqmParameter = entry.getValue().get( 0 );
-			if ( sqmParameter instanceof SqmJpaCriteriaParameterWrapper<?> wrapper ) {
-				final var criteriaParameter =
-						(JpaCriteriaParameter<?>)
-								wrapper.getJpaCriteriaParameter();
-				if ( criteriaParameter instanceof ValueBindJpaCriteriaParameter<?> ) {
-					// Use the anticipated type for binding the value if possible
-					final var parameter = (QueryParameterImplementor<?>) entry.getKey();
-					bindings.getBinding( parameter )
-							.setBindValue( criteriaParameter.getValue(),
-									criteriaParameter.getAnticipatedType() );
-				}
+			bindValueToCriteriaParameter( bindings, entry.getKey(),
+					entry.getValue().get( 0 ) );
+		}
+	}
+
+	private static <T> void bindValueToCriteriaParameter(
+			QueryParameterBindings bindings,
+			QueryParameterImplementor<?> queryParameterImplementor,
+			SqmParameter<T> sqmParameter) {
+		if ( sqmParameter instanceof SqmJpaCriteriaParameterWrapper<T> wrapper ) {
+			final var criteriaParameter = wrapper.getJpaCriteriaParameter();
+			if ( criteriaParameter instanceof ValueBindJpaCriteriaParameter<T> ) {
+				// Use the anticipated type for binding the value if possible
+				bindings.getBinding( queryParameterImplementor )
+						.setBindValue( criteriaParameter.getValue(),
+								criteriaParameter.getAnticipatedType() );
 			}
 		}
 	}

hibernate-core/src/test/java/org/hibernate/orm/test/procedure/StoredProcedureParameterTypeTest.java

@@ -452,7 +452,7 @@ public void testTypedParameterValueInParameterWithNotSpecifiedType(SessionFactor
 						procedureCall.setParameter( 1, TypedParameterValue.of( StandardBasicTypes.INTEGER, 1 ) );
 					}
 					catch (IllegalArgumentException e) {
-						assertTrue( e.getMessage().contains( "incompatible type" ) );
+						assertTrue( e.getMessage().contains( "incompatible" ) );
 					}
 				}
 		);