Skip to content

Commit 8c4cde0

Browse files
gavinkinggavinking
committed
HHH-19445 ProcedureCall should accept BindableType, not BasicTypeReference
1 parent 48430ea commit 8c4cde0

File tree

3 files changed

+43
-40
lines changed

3 files changed

+43
-40
lines changed

‎hibernate-core/src/main/java/org/hibernate/procedure/ProcedureCall.java‎

Lines changed: 12 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -15,10 +15,10 @@
1515
import jakarta.persistence.TemporalType;
1616

1717
import org.hibernate.MappingException;
18+
import org.hibernate.query.BindableType;
1819
import org.hibernate.query.SynchronizeableQuery;
1920
import org.hibernate.query.CommonQueryContract;
2021
import org.hibernate.query.procedure.ProcedureParameter;
21-
import org.hibernate.type.BasicTypeReference;
2222

2323
/**
2424
* Defines support for executing database stored procedures and functions.
@@ -74,7 +74,7 @@ public interface ProcedureCall
7474
boolean isFunctionCall();
7575

7676
/**
77-
* Mark this ProcedureCall as representing a call to a database function,
77+
* Mark this {@code ProcedureCall} as representing a call to a database function,
7878
* rather than a database procedure.
7979
*
8080
* @param sqlType The {@link java.sql.Types} code for the function return
@@ -84,7 +84,7 @@ public interface ProcedureCall
8484
ProcedureCall markAsFunctionCall(int sqlType);
8585

8686
/**
87-
* Mark this ProcedureCall as representing a call to a database function,
87+
* Mark this {@code ProcedureCall} as representing a call to a database function,
8888
* rather than a database procedure.
8989
*
9090
* @param resultType The result type for the function return
@@ -95,15 +95,15 @@ public interface ProcedureCall
9595
ProcedureCall markAsFunctionCall(Class<?> resultType);
9696

9797
/**
98-
* Mark this ProcedureCall as representing a call to a database function,
98+
* Mark this {@code ProcedureCall} as representing a call to a database function,
9999
* rather than a database procedure.
100100
*
101101
* @param typeReference The result type for the function return
102102
*
103103
* @return {@code this}, for method chaining
104104
* @since 6.2
105105
*/
106-
ProcedureCall markAsFunctionCall(BasicTypeReference<?> typeReference);
106+
ProcedureCall markAsFunctionCall(BindableType<?> typeReference);
107107

108108
/**
109109
* Basic form for registering a positional parameter.
@@ -127,13 +127,13 @@ public interface ProcedureCall
127127
*
128128
* @return The parameter registration memento
129129
*/
130-
<T> ProcedureParameter<T> registerParameter(int position, BasicTypeReference<T> type, ParameterMode mode);
130+
<T> ProcedureParameter<T> registerParameter(int position, BindableType<T> type, ParameterMode mode);
131131

132132
/**
133-
* Like {@link #registerStoredProcedureParameter(int, Class, ParameterMode)} but a basic type reference is given
133+
* Like {@link #registerStoredProcedureParameter(int, Class, ParameterMode)} but a type reference is given
134134
* instead of a class for the parameter type.
135135
*/
136-
ProcedureCall registerStoredProcedureParameter(int position, BasicTypeReference<?> type, ParameterMode mode);
136+
ProcedureCall registerStoredProcedureParameter(int position, BindableType<?> type, ParameterMode mode);
137137

138138
/**
139139
* Retrieve a previously registered parameter memento by the position under which it was registered.
@@ -176,14 +176,14 @@ <T> ProcedureParameter<T> registerParameter(String parameterName, Class<T> type,
176176
* @throws NamedParametersNotSupportedException When the underlying database is known to not support
177177
* named procedure parameters.
178178
*/
179-
<T> ProcedureParameter<T> registerParameter(String parameterName, BasicTypeReference<T> type, ParameterMode mode)
179+
<T> ProcedureParameter<T> registerParameter(String parameterName, BindableType<T> type, ParameterMode mode)
180180
throws NamedParametersNotSupportedException;
181181

182182
/**
183-
* Like {@link #registerStoredProcedureParameter(String, Class, ParameterMode)} but a basic type reference is given
183+
* Like {@link #registerStoredProcedureParameter(String, Class, ParameterMode)} but a type reference is given
184184
* instead of a class for the parameter type.
185185
*/
186-
ProcedureCall registerStoredProcedureParameter(String parameterName, BasicTypeReference<?> type, ParameterMode mode);
186+
ProcedureCall registerStoredProcedureParameter(String parameterName, BindableType<?> type, ParameterMode mode);
187187

188188
/**
189189
* Retrieve a previously registered parameter memento by the name under which it was registered.
@@ -223,9 +223,7 @@ default void close() {
223223
getOutputs().release();
224224
}
225225

226-
/*
227-
Covariant overrides
228-
*/
226+
/* Covariant overrides */
229227

230228
@Override
231229
ProcedureCall addSynchronizedQuerySpace(String querySpace);

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

Lines changed: 22 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -74,7 +74,6 @@
7474
import org.hibernate.sql.exec.spi.JdbcParameterBindings;
7575
import org.hibernate.sql.results.NoMoreOutputsException;
7676
import org.hibernate.type.BasicType;
77-
import org.hibernate.type.BasicTypeReference;
7877
import org.hibernate.type.spi.TypeConfiguration;
7978

8079
import jakarta.persistence.CacheRetrieveMode;
@@ -385,13 +384,19 @@ public ProcedureCallImpl<R> markAsFunctionCall(Class<?> resultType) {
385384
}
386385

387386
@Override
388-
public ProcedureCallImpl<R> markAsFunctionCall(BasicTypeReference<?> typeReference) {
389-
final BasicType<?> basicType =
390-
getTypeConfiguration().getBasicTypeRegistry().resolve( typeReference );
391-
if ( basicType == null ) {
392-
throw new IllegalArgumentException( "Could not resolve a BasicType for the java type: " + typeReference.getName() );
387+
public ProcedureCall markAsFunctionCall(BindableType<?> typeReference) {
388+
if ( !(typeReference instanceof OutputableType<?> outputableType) ) {
389+
throw new IllegalArgumentException( "Given type is not an OutputableType: " + typeReference );
393390
}
394-
markAsFunctionCall( basicType );
391+
if ( resultSetMapping.getNumberOfResultBuilders() == 0 ) {
392+
final SqmExpressible<?> expressible =
393+
typeReference.resolveExpressible( getSessionFactory().getRuntimeMetamodels() );
394+
// Function returns might not be represented as callable parameters,
395+
// but we still want to convert the result to the requested java type if possible
396+
resultSetMapping.addResultBuilder( new ScalarDomainResultBuilder<>( expressible.getExpressibleJavaType() ) );
397+
}
398+
//noinspection unchecked
399+
functionReturn = new FunctionReturnImpl<>( this, (OutputableType<R>) outputableType );
395400
return this;
396401
}
397402

@@ -452,7 +457,7 @@ public ProcedureCallImplementor<R> registerStoredProcedureParameter(
452457
@Override
453458
public ProcedureCallImplementor<R> registerStoredProcedureParameter(
454459
int position,
455-
BasicTypeReference<?> type,
460+
BindableType<?> type,
456461
ParameterMode mode) {
457462
getSession().checkOpen( true );
458463

@@ -472,7 +477,7 @@ public ProcedureCallImplementor<R> registerStoredProcedureParameter(
472477
@Override
473478
public ProcedureCallImplementor<R> registerStoredProcedureParameter(
474479
String parameterName,
475-
BasicTypeReference<?> type,
480+
BindableType<?> type,
476481
ParameterMode mode) {
477482
getSession().checkOpen( true );
478483
try {
@@ -501,12 +506,12 @@ public <T> ProcedureParameter<T> registerParameter(int position, Class<T> javaTy
501506
@Override
502507
public <T> ProcedureParameter<T> registerParameter(
503508
int position,
504-
BasicTypeReference<T> typeReference,
509+
BindableType<T> typeReference,
505510
ParameterMode mode) {
506-
final BasicType<T> basicType =
507-
getTypeConfiguration().getBasicTypeRegistry().resolve( typeReference );
511+
final SqmExpressible<T> expressible =
512+
typeReference.resolveExpressible( getSessionFactory().getRuntimeMetamodels() );
508513
final ProcedureParameterImpl<T> procedureParameter =
509-
new ProcedureParameterImpl<>( position, mode, basicType.getJavaType(), basicType );
514+
new ProcedureParameterImpl<>( position, mode, typeReference.getBindableJavaType(), expressible );
510515
registerParameter( procedureParameter );
511516
return procedureParameter;
512517
}
@@ -545,12 +550,12 @@ private <T> Class<T> getExpressibleJavaType(BindableType<T> parameterType) {
545550
@Override
546551
public <T> ProcedureParameterImplementor<T> registerParameter(
547552
String name,
548-
BasicTypeReference<T> typeReference,
553+
BindableType<T> typeReference,
549554
ParameterMode mode) {
550-
final BasicType<T> basicType =
551-
getTypeConfiguration().getBasicTypeRegistry().resolve( typeReference );
555+
final SqmExpressible<T> expressible =
556+
typeReference.resolveExpressible( getSessionFactory().getRuntimeMetamodels() );
552557
final ProcedureParameterImpl<T> parameter =
553-
new ProcedureParameterImpl<>( name, mode, basicType.getJavaType(), basicType );
558+
new ProcedureParameterImpl<>( name, mode, typeReference.getBindableJavaType(), expressible );
554559
registerParameter( parameter );
555560
return parameter;
556561
}

‎hibernate-core/src/main/java/org/hibernate/procedure/spi/ProcedureCallImplementor.java‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -9,10 +9,10 @@
99
import java.util.List;
1010

1111
import org.hibernate.procedure.ProcedureCall;
12+
import org.hibernate.query.BindableType;
1213
import org.hibernate.query.named.NameableQuery;
1314
import org.hibernate.query.spi.ProcedureParameterMetadataImplementor;
1415
import org.hibernate.query.spi.QueryImplementor;
15-
import org.hibernate.type.BasicTypeReference;
1616

1717
import jakarta.persistence.CacheRetrieveMode;
1818
import jakarta.persistence.CacheStoreMode;
@@ -41,10 +41,16 @@ default List<R> getResultList() {
4141
R getSingleResult();
4242

4343
@Override
44-
ProcedureCallImplementor<R> registerStoredProcedureParameter(int position, BasicTypeReference<?> type, ParameterMode mode);
44+
ProcedureCallImplementor<R> registerStoredProcedureParameter(int position, Class<?> type, ParameterMode mode);
45+
46+
@Override
47+
ProcedureCallImplementor<R> registerStoredProcedureParameter(String parameterName, Class<?> type, ParameterMode mode);
48+
49+
@Override
50+
ProcedureCallImplementor<R> registerStoredProcedureParameter(int position, BindableType<?> type, ParameterMode mode);
4551

4652
@Override
47-
ProcedureCallImplementor<R> registerStoredProcedureParameter(String parameterName, BasicTypeReference<?> type, ParameterMode mode);
53+
ProcedureCallImplementor<R> registerStoredProcedureParameter(String parameterName, BindableType<?> type, ParameterMode mode);
4854

4955
@Override
5056
ProcedureCallImplementor<R> setHint(String hintName, Object value);
@@ -88,12 +94,6 @@ default List<R> getResultList() {
8894
@Override
8995
ProcedureCallImplementor<R> setTimeout(Integer timeout);
9096

91-
@Override
92-
ProcedureCallImplementor<R> registerStoredProcedureParameter(int position, Class<?> type, ParameterMode mode);
93-
94-
@Override
95-
ProcedureCallImplementor<R> registerStoredProcedureParameter(String parameterName, Class<?> type, ParameterMode mode);
96-
9797
@Override
9898
NamedCallableQueryMemento toMemento(String name);
9999
}

0 commit comments

Comments
 (0)