HHH-19449 mopping up and jdoc after apocalypse

Author: gavinking

hibernate-core/src/main/java/org/hibernate/procedure/internal/ProcedureCallImpl.java

@@ -502,7 +502,7 @@ public <T> ProcedureParameter<T> registerParameter(
 			ParameterMode mode) {
 		final SqmBindableType<T> expressible = resolveExpressible( typeReference );
 		final ProcedureParameterImpl<T> procedureParameter =
-				new ProcedureParameterImpl<>( position, mode, ((BindableType<T>) typeReference).getJavaType(), expressible );
+				new ProcedureParameterImpl<>( position, mode, typeReference.getJavaType(), expressible );
 		registerParameter( procedureParameter );
 		return procedureParameter;
 	}
@@ -552,7 +552,7 @@ public <T> ProcedureParameterImplementor<T> registerParameter(
 			ParameterMode mode) {
 		final SqmBindableType<T> expressible = resolveExpressible( typeReference );
 		final ProcedureParameterImpl<T> parameter =
-				new ProcedureParameterImpl<>( name, mode, ((BindableType<T>) typeReference).getJavaType(), expressible );
+				new ProcedureParameterImpl<>( name, mode, typeReference.getJavaType(), expressible );
 		registerParameter( parameter );
 		return parameter;
 	}

hibernate-core/src/main/java/org/hibernate/procedure/internal/ProcedureParameterImpl.java

@@ -103,16 +103,14 @@ public JdbcCallParameterRegistration toJdbcParameterRegistration(
 			ProcedureCallImplementor<?> procedureCall) {
 		final QueryParameterBinding<T> binding = procedureCall.getParameterBindings().getBinding( this );
 		final boolean isNamed = procedureCall.getParameterStrategy() == ParameterStrategy.NAMED && this.name != null;
-
-		final BindableType<T> bindableType = getBindableType( binding );
-
 		final SharedSessionContractImplementor session = procedureCall.getSession();
 
-		final OutputableType<T> typeToUse = (OutputableType<T>) BindingTypeHelper.INSTANCE.resolveTemporalPrecision(
-				binding == null ? null : binding.getExplicitTemporalPrecision(),
-				bindableType,
-				session.getFactory().getQueryEngine().getCriteriaBuilder()
-		);
+		final OutputableType<T> typeToUse = (OutputableType<T>)
+				BindingTypeHelper.resolveTemporalPrecision(
+						binding == null ? null : binding.getExplicitTemporalPrecision(),
+						getBindableType( binding ),
+						session.getFactory().getQueryEngine().getCriteriaBuilder()
+				);
 
 		final String jdbcParamName;
 		final JdbcParameterBinder parameterBinder;

hibernate-core/src/main/java/org/hibernate/query/CommonQueryContract.java

@@ -33,8 +33,26 @@
  * Queries may have <em>parameters</em>, either ordinal or named, and the various
  * {@code setParameter()} operations of this interface allow an argument to be
  * bound to a parameter. It's not usually necessary to explicitly specify the type
- * of an argument, but in rare cases where this is needed, {@link TypedParameterValue}
- * may be used.
+ * of an argument, but in rare cases where this is needed:
+ * <ul>
+ * <li>an instance of an appropriate metamodel {@link Type} may be passed to
+ *     {@link #setParameter(int, Object, Type)}, or
+ * <li>the argument may be wrapped in a {@link TypedParameterValue}. (For JPA users,
+ *     this second option avoids the need to cast the {@link jakarta.persistence.Query}
+ *     to a Hibernate-specific type.)
+ * </ul>
+ * <p>
+ * For example:
+ * <pre>
+ * session.createSelectionQuery("from Person where address = :address", Person.class)
+ *         .setParameter("address", address, Person_.address.getType())
+ *         .getResultList()
+ * </pre>
+ * <pre>
+ * entityManager.createQuery( "from Person where address = :address", Person.class)
+ *         .setParameter("address", TypedParameterValue.of(Person_.address.getType(), address))
+ *         .getResultList()
+ * </pre>
  * <p>
  * The operation {@link #setQueryFlushMode(QueryFlushMode)} allows a temporary flush
  * mode to be specified, which is in effect only during the execution of this query.

hibernate-core/src/main/java/org/hibernate/query/TypedParameterValue.java

@@ -4,6 +4,7 @@
  */
 package org.hibernate.query;
 
+import jakarta.persistence.metamodel.Type;
 import org.hibernate.type.BindableType;
 import org.hibernate.type.BasicTypeReference;
 
@@ -25,6 +26,10 @@
  * query.setParameter("stringNamedParam",
  *         TypedParameterValue.ofNull(StandardBasicTypes.STRING))
  * </pre>
+ * <pre>
+ * query.setParameter("address",
+ *         TypedParameterValue.of(Address_.class_, address))
+ * </pre>
  * <p>
  * Here, a "null string" argument was bound to the named parameter
  * {@code :stringNamedParam}.
@@ -51,17 +56,17 @@ public record TypedParameterValue<J>(BindableType<J> type, J value) {
 	 *
 	 * @since 7.0
 	 */
-	public static <J> TypedParameterValue<J> of(BindableType<J> type, J value) {
-		return new TypedParameterValue<>( type, value );
+	public static <J> TypedParameterValue<J> of(Type<J> type, J value) {
+		return new TypedParameterValue<>( (BindableType<J>) type, value );
 	}
 
 	/**
 	 * Obtain an instance with the given type and a null value.
 	 *
 	 * @since 7.0
 	 */
-	public static <J> TypedParameterValue<J> ofNull(BindableType<J> type) {
-		return new TypedParameterValue<>( type, null );
+	public static <J> TypedParameterValue<J> ofNull(Type<J> type) {
+		return new TypedParameterValue<>( (BindableType<J>) type, null );
 	}
 
 	/**

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

@@ -249,7 +249,7 @@ public void setBindValues(
 	private void setExplicitTemporalPrecision(TemporalType precision) {
 		explicitTemporalPrecision = precision;
 		if ( bindType == null || JavaTypeHelper.isTemporal( determineJavaType( bindType ) ) ) {
-			bindType = BindingTypeHelper.INSTANCE.resolveTemporalPrecision( precision, bindType, getCriteriaBuilder() );
+			bindType = BindingTypeHelper.resolveTemporalPrecision( precision, bindType, getCriteriaBuilder() );
 		}
 	}
 

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

@@ -27,7 +27,7 @@ private QueryParameterBindingValidator() {
 	}
 
 	public void validate(BindableType<?> paramType, Object bind, BindingContext bindingContext) {
-		validate( paramType, bind, null, bindingContext);
+		validate( paramType, bind, null, bindingContext );
 	}
 
 	public void validate(

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

@@ -14,9 +14,10 @@
 import org.hibernate.metamodel.mapping.JdbcMapping;
 import org.hibernate.sql.ast.tree.expression.JdbcParameter;
 import org.hibernate.sql.exec.internal.JdbcParameterBindingImpl;
-import org.hibernate.type.internal.BindingTypeHelper;
 import org.hibernate.type.spi.TypeConfiguration;
 
+import static org.hibernate.type.internal.BindingTypeHelper.resolveBindType;
+
 /**
  * Access to all the externalized JDBC parameter bindings
  *
@@ -93,10 +94,7 @@ private void createAndAddBinding(
 			JdbcMapping type) {
 		addBinding(
 				params.get( selectionIndex ),
-				new JdbcParameterBindingImpl(
-						BindingTypeHelper.INSTANCE.resolveBindType( jdbcValue, type, typeConfiguration ),
-						jdbcValue
-				)
+				new JdbcParameterBindingImpl( resolveBindType( jdbcValue, type, typeConfiguration ), jdbcValue )
 		);
 	}
 }

hibernate-core/src/main/java/org/hibernate/type/descriptor/java/TemporalJavaType.java

@@ -20,27 +20,19 @@
 public interface TemporalJavaType<T> extends BasicJavaType<T> {
 
 	static int resolveJdbcTypeCode(TemporalType requestedTemporalPrecision) {
-		switch ( requestedTemporalPrecision ) {
-			case DATE:
-				return Types.DATE;
-			case TIME:
-				return Types.TIME;
-			case TIMESTAMP:
-				return Types.TIMESTAMP;
-		}
-		throw new UnsupportedOperationException( "Unsupported precision: " + requestedTemporalPrecision );
+		return switch ( requestedTemporalPrecision ) {
+			case DATE -> Types.DATE;
+			case TIME -> Types.TIME;
+			case TIMESTAMP -> Types.TIMESTAMP;
+		};
 	}
 
 	static Class<?> resolveJavaTypeClass(TemporalType requestedTemporalPrecision) {
-		switch ( requestedTemporalPrecision ) {
-			case DATE:
-				return java.sql.Date.class;
-			case TIME:
-				return java.sql.Time.class;
-			case TIMESTAMP:
-				return java.sql.Timestamp.class;
-		}
-		throw new UnsupportedOperationException( "Unsupported precision: " + requestedTemporalPrecision );
+		return switch ( requestedTemporalPrecision ) {
+			case DATE -> java.sql.Date.class;
+			case TIME -> java.sql.Time.class;
+			case TIMESTAMP -> java.sql.Timestamp.class;
+		};
 	}
 
 	/**