HHH-18649 populate TypedQueryReference in static metamodel

hibernate-core/src/main/java/org/hibernate/boot/internal/NamedHqlQueryDefinitionImpl.java

@@ -42,7 +42,8 @@ public NamedHqlQueryDefinitionImpl(
 			Integer fetchSize,
 			String comment,
 			Map<String,String> parameterTypes,
-			Map<String,Object> hints) {
+			Map<String,Object> hints,
+			String location) {
 		super(
 				name,
 				resultType,
@@ -55,7 +56,8 @@ public NamedHqlQueryDefinitionImpl(
 				timeout,
 				fetchSize,
 				comment,
-				hints
+				hints,
+				location
 		);
 		this.hqlString = hqlString;
 		this.firstResult = firstResult;

hibernate-core/src/main/java/org/hibernate/boot/internal/NamedNativeQueryDefinitionImpl.java

@@ -44,7 +44,8 @@ public NamedNativeQueryDefinitionImpl(
 			String comment,
 			Integer firstResult,
 			Integer maxResults,
-			Map<String,Object> hints) {
+			Map<String,Object> hints,
+			String location) {
 		super(
 				name,
 				resultType,
@@ -57,7 +58,8 @@ public NamedNativeQueryDefinitionImpl(
 				timeout,
 				fetchSize,
 				comment,
-				hints
+				hints,
+				location
 		);
 		this.sqlString = sqlString;
 		this.resultSetMappingName = resultSetMappingName;

hibernate-core/src/main/java/org/hibernate/boot/internal/NamedProcedureCallDefinitionImpl.java

@@ -10,6 +10,7 @@
 import java.util.Map;
 import java.util.Set;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.hibernate.CacheMode;
 import org.hibernate.FlushMode;
 import org.hibernate.MappingException;
@@ -74,6 +75,12 @@ public String getRegistrationName() {
 		return registeredName;
 	}
 
+	@Override
+	public @Nullable String getLocation() {
+		// not kept for now
+		return null;
+	}
+
 	@Override
 	public String getProcedureName() {
 		return procedureName;
@@ -203,4 +210,9 @@ public ParameterMemento toMemento(SessionFactoryImplementor sessionFactory) {
 	private static String normalize(String name) {
 		return StringHelper.isNotEmpty( name ) ? name : null;
 	}
+
+	@Override
+	public Map<String, Object> getHints() {
+		return hints;
+	}
 }

hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationBinder.java

@@ -104,11 +104,11 @@ public static void bindDefaults(MetadataBuildingContext context) {
 		// queries ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 		globalRegistrations.getNamedQueryRegistrations().forEach( (name, queryRegistration) -> {
-			QueryBinder.bindQuery( queryRegistration.configuration(), context, true );
+			QueryBinder.bindQuery( queryRegistration.configuration(), context, true, null );
 		} );
 
 		globalRegistrations.getNamedNativeQueryRegistrations().forEach( (name, queryRegistration) -> {
-			QueryBinder.bindNativeQuery( queryRegistration.configuration(), context, true );
+			QueryBinder.bindNativeQuery( queryRegistration.configuration(), context, null, true );
 		} );
 
 		globalRegistrations.getNamedStoredProcedureQueryRegistrations().forEach( (name, queryRegistration) -> {
@@ -152,13 +152,13 @@ private static void bindNamedHibernateQueries(AnnotationTarget annotationTarget,
 		annotationTarget.forEachRepeatedAnnotationUsages(
 				HibernateAnnotations.NAMED_QUERY,
 				sourceModelContext,
-				(usage) -> QueryBinder.bindQuery( usage, context )
+				(usage) -> QueryBinder.bindQuery( usage, context, annotationTarget )
 		);
 
 		annotationTarget.forEachRepeatedAnnotationUsages(
 				HibernateAnnotations.NAMED_NATIVE_QUERY,
 				sourceModelContext,
-				(usage) -> QueryBinder.bindNativeQuery( usage, context )
+				(usage) -> QueryBinder.bindNativeQuery( usage, context, annotationTarget )
 		);
 	}
 
@@ -174,13 +174,13 @@ private static void bindNamedJpaQueries(AnnotationTarget annotationTarget, Metad
 		annotationTarget.forEachRepeatedAnnotationUsages(
 				JpaAnnotations.NAMED_QUERY,
 				sourceModelContext,
-				(usage) -> QueryBinder.bindQuery( usage, context, false )
+				(usage) -> QueryBinder.bindQuery( usage, context, false, annotationTarget )
 		);
 
 		annotationTarget.forEachRepeatedAnnotationUsages(
 				JpaAnnotations.NAMED_NATIVE_QUERY,
 				sourceModelContext,
-				(usage) -> QueryBinder.bindNativeQuery( usage, context, false )
+				(usage) -> QueryBinder.bindNativeQuery( usage, context, annotationTarget, false )
 		);
 
 		annotationTarget.forEachRepeatedAnnotationUsages(

hibernate-core/src/main/java/org/hibernate/boot/model/internal/QueryBinder.java

@@ -14,6 +14,7 @@
 import org.hibernate.AnnotationException;
 import org.hibernate.CacheMode;
 import org.hibernate.FlushMode;
+import org.hibernate.models.spi.AnnotationTarget;
 import org.hibernate.query.QueryFlushMode;
 import org.hibernate.LockOptions;
 import org.hibernate.annotations.FlushModeType;
@@ -74,7 +75,8 @@ public abstract class QueryBinder {
 	public static void bindQuery(
 			NamedQuery namedQuery,
 			MetadataBuildingContext context,
-			boolean isDefault) {
+			boolean isDefault,
+			AnnotationTarget annotationTarget) {
 		if ( namedQuery == null ) {
 			return;
 		}
@@ -94,7 +96,7 @@ public static void bindQuery(
 		final QueryHintDefinition hints = new QueryHintDefinition( queryName, namedQuery.hints() );
 		final NamedHqlQueryDefinition<?> queryMapping =
 				createNamedQueryDefinition( queryName, queryString, resultClass,
-						hints.determineLockOptions( namedQuery ), hints );
+						hints.determineLockOptions( namedQuery ), hints, annotationTarget );
 		if ( isDefault ) {
 			context.getMetadataCollector().addDefaultQuery( queryMapping );
 		}
@@ -105,8 +107,8 @@ public static void bindQuery(
 
 	private static <T> NamedHqlQueryDefinitionImpl<T> createNamedQueryDefinition(
 			String queryName, String queryString, Class<T> resultClass, LockOptions lockOptions,
-			QueryHintDefinition hints) {
-		return new NamedHqlQueryDefinitionImpl.Builder<T>(queryName)
+			QueryHintDefinition hints, AnnotationTarget annotationTarget) {
+		return new NamedHqlQueryDefinitionImpl.Builder<T>(queryName, annotationTarget)
 				.setHqlString(queryString)
 				.setResultClass(resultClass)
 				.setCacheable(hints.getCacheability())
@@ -124,6 +126,7 @@ private static <T> NamedHqlQueryDefinitionImpl<T> createNamedQueryDefinition(
 	public static void bindNativeQuery(
 			NamedNativeQuery namedNativeQuery,
 			MetadataBuildingContext context,
+			AnnotationTarget location,
 			boolean isDefault) {
 		if ( namedNativeQuery == null ) {
 			return;
@@ -143,7 +146,7 @@ public static void bindNativeQuery(
 		final Class<?> resultClass = void.class == resultClassDetails ? null : resultClassDetails;
 
 		final NamedNativeQueryDefinition<?> queryDefinition =
-				createNamedQueryDefinition( registrationName, queryString, resultClass, resultSetMappingName, hints );
+				createNamedQueryDefinition( registrationName, queryString, resultClass, resultSetMappingName, hints, location );
 
 		if ( LOG.isDebugEnabled() ) {
 			LOG.debugf( "Binding named native query: %s => %s",
@@ -161,8 +164,9 @@ public static void bindNativeQuery(
 	private static <T> NamedNativeQueryDefinition<T> createNamedQueryDefinition(
 			String registrationName, String queryString,
 			Class<T> resultClass, String resultSetMappingName,
-			QueryHintDefinition hints) {
-		return new NamedNativeQueryDefinition.Builder<T>(registrationName)
+			QueryHintDefinition hints,
+			AnnotationTarget location) {
+		return new NamedNativeQueryDefinition.Builder<T>(registrationName, location)
 				.setSqlString(queryString)
 				.setResultClass(resultClass)
 				.setResultSetMappingName(resultSetMappingName)
@@ -184,10 +188,11 @@ public static void bindNativeQuery(
 			SQLSelect sqlSelect,
 			ClassDetails annotatedClass,
 			MetadataBuildingContext context) {
-		final NamedNativeQueryDefinition.Builder<?> builder = new NamedNativeQueryDefinition.Builder<>( name )
-				.setFlushMode( FlushMode.MANUAL )
-				.setSqlString( sqlSelect.sql() )
-				.setQuerySpaces( setOf( sqlSelect.querySpaces() ) );
+		final NamedNativeQueryDefinition.Builder<?> builder =
+				new NamedNativeQueryDefinition.Builder<>( name )
+						.setFlushMode( FlushMode.MANUAL )
+						.setSqlString( sqlSelect.sql() )
+						.setQuerySpaces( setOf( sqlSelect.querySpaces() ) );
 
 		if ( annotatedClass != null ) {
 			builder.setResultClass(
@@ -210,7 +215,8 @@ public static void bindNativeQuery(
 
 	public static void bindNativeQuery(
 			org.hibernate.annotations.NamedNativeQuery namedNativeQuery,
-			MetadataBuildingContext context) {
+			MetadataBuildingContext context,
+			AnnotationTarget location) {
 		if ( namedNativeQuery == null ) {
 			return;
 		}
@@ -231,7 +237,7 @@ public static void bindNativeQuery(
 
 		final NamedNativeQueryDefinition.Builder<?> builder =
 				createQueryDefinition( namedNativeQuery, registrationName, resultSetMappingName, resultClass,
-						namedNativeQuery.timeout(), namedNativeQuery.fetchSize(), querySpaces );
+						namedNativeQuery.timeout(), namedNativeQuery.fetchSize(), querySpaces, location );
 
 		if ( TRUE == namedNativeQuery.callable() ) {
 			final NamedProcedureCallDefinition definition =
@@ -261,8 +267,9 @@ private static <T> NamedNativeQueryDefinition.Builder<T> createQueryDefinition(
 			String registrationName, String resultSetMappingName,
 			Class<T> resultClass,
 			int timeout, int fetchSize,
-			HashSet<String> querySpaces) {
-		return new NamedNativeQueryDefinition.Builder<T>(registrationName)
+			HashSet<String> querySpaces,
+			AnnotationTarget location) {
+		return new NamedNativeQueryDefinition.Builder<T>(registrationName, location)
 				.setSqlString(namedNativeQuery.query())
 				.setResultSetMappingName(resultSetMappingName)
 				.setResultClass(resultClass)
@@ -365,17 +372,18 @@ public static void bindQuery(
 			String name,
 			HQLSelect hqlSelect,
 			MetadataBuildingContext context) {
-		final NamedHqlQueryDefinition<?> hqlQueryDefinition = new NamedHqlQueryDefinition.Builder<>( name )
-				.setFlushMode( FlushMode.MANUAL )
-				.setHqlString( hqlSelect.query() )
-				.build();
-
+		final NamedHqlQueryDefinition<?> hqlQueryDefinition =
+				new NamedHqlQueryDefinition.Builder<>( name )
+						.setFlushMode( FlushMode.MANUAL )
+						.setHqlString( hqlSelect.query() )
+						.build();
 		context.getMetadataCollector().addNamedQuery( hqlQueryDefinition );
 	}
 
 	public static void bindQuery(
 			org.hibernate.annotations.NamedQuery namedQuery,
-			MetadataBuildingContext context) {
+			MetadataBuildingContext context,
+			AnnotationTarget location) {
 		if ( namedQuery == null ) {
 			return;
 		}
@@ -389,7 +397,7 @@ public static void bindQuery(
 
 		final NamedHqlQueryDefinition.Builder<?> builder =
 				createQueryDefinition( namedQuery, registrationName, resultClass,
-						namedQuery.timeout(), namedQuery.fetchSize() ) ;
+						namedQuery.timeout(), namedQuery.fetchSize(), location ) ;
 
 		final NamedHqlQueryDefinitionImpl<?> hqlQueryDefinition = builder.build();
 
@@ -403,8 +411,9 @@ public static void bindQuery(
 
 	private static <T> NamedHqlQueryDefinition.Builder<T> createQueryDefinition(
 			org.hibernate.annotations.NamedQuery namedQuery,
-			String registrationName, Class<T> resultClass, int timeout, int fetchSize) {
-		return new NamedHqlQueryDefinition.Builder<T>(registrationName)
+			String registrationName, Class<T> resultClass, int timeout, int fetchSize,
+			AnnotationTarget location) {
+		return new NamedHqlQueryDefinition.Builder<T>(registrationName, location)
 				.setHqlString(namedQuery.query())
 				.setResultClass(resultClass)
 				.setCacheable(namedQuery.cacheable())

hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/NamedQueryBinder.java

@@ -47,15 +47,16 @@ public static void processNamedQuery(
 			String prefix) {
 		final String registrationName = prefix + namedQueryBinding.getName();
 
-		final NamedHqlQueryDefinition.Builder<?> queryBuilder = new NamedHqlQueryDefinition.Builder<>( registrationName )
-				.setComment( namedQueryBinding.getComment() )
-				.setCacheable( namedQueryBinding.isCacheable() )
-				.setCacheMode( namedQueryBinding.getCacheMode() )
-				.setCacheRegion( namedQueryBinding.getCacheRegion() )
-				.setTimeout( namedQueryBinding.getTimeout() )
-				.setReadOnly( namedQueryBinding.isReadOnly() )
-				.setFlushMode( namedQueryBinding.getFlushMode() )
-				.setFetchSize( namedQueryBinding.getFetchSize() );
+		final NamedHqlQueryDefinition.Builder<?> queryBuilder =
+				new NamedHqlQueryDefinition.Builder<>( registrationName )
+						.setComment( namedQueryBinding.getComment() )
+						.setCacheable( namedQueryBinding.isCacheable() )
+						.setCacheMode( namedQueryBinding.getCacheMode() )
+						.setCacheRegion( namedQueryBinding.getCacheRegion() )
+						.setTimeout( namedQueryBinding.getTimeout() )
+						.setReadOnly( namedQueryBinding.isReadOnly() )
+						.setFlushMode( namedQueryBinding.getFlushMode() )
+						.setFetchSize( namedQueryBinding.getFetchSize() );
 
 		boolean foundQuery = false;
 
@@ -109,16 +110,17 @@ public static void processNamedNativeQuery(
 
 		final String registrationName = prefix + namedQueryBinding.getName();
 
-		final NamedNativeQueryDefinition.Builder<?> builder = new NamedNativeQueryDefinition.Builder<>( registrationName )
-				.setComment( namedQueryBinding.getComment() )
-				.setCacheable( namedQueryBinding.isCacheable() )
-				.setCacheMode( namedQueryBinding.getCacheMode() )
-				.setCacheRegion( namedQueryBinding.getCacheRegion() )
-				.setTimeout( namedQueryBinding.getTimeout() )
-				.setReadOnly( namedQueryBinding.isReadOnly() )
-				.setFlushMode( namedQueryBinding.getFlushMode() )
-				.setFetchSize( namedQueryBinding.getFetchSize() )
-				.setResultSetMappingName( namedQueryBinding.getResultsetRef() );
+		final NamedNativeQueryDefinition.Builder<?> builder =
+				new NamedNativeQueryDefinition.Builder<>( registrationName )
+						.setComment( namedQueryBinding.getComment() )
+						.setCacheable( namedQueryBinding.isCacheable() )
+						.setCacheMode( namedQueryBinding.getCacheMode() )
+						.setCacheRegion( namedQueryBinding.getCacheRegion() )
+						.setTimeout( namedQueryBinding.getTimeout() )
+						.setReadOnly( namedQueryBinding.isReadOnly() )
+						.setFlushMode( namedQueryBinding.getFlushMode() )
+						.setFetchSize( namedQueryBinding.getFetchSize() )
+						.setResultSetMappingName( namedQueryBinding.getResultsetRef() );
 
 		final ImplicitHbmResultSetMappingDescriptorBuilder implicitResultSetMappingBuilder =
 				new ImplicitHbmResultSetMappingDescriptorBuilder( registrationName, context );
@@ -222,12 +224,10 @@ else if ( content instanceof JAXBElement ) {
 			);
 		}
 
-		if ( content instanceof JaxbHbmQueryParamType ) {
-			final JaxbHbmQueryParamType paramTypeBinding = (JaxbHbmQueryParamType) content;
+		if ( content instanceof JaxbHbmQueryParamType paramTypeBinding ) {
 			queryBuilder.addParameterTypeHint( paramTypeBinding.getName(), paramTypeBinding.getType() );
 		}
-		else if ( content instanceof JaxbHbmSynchronizeType ) {
-			final JaxbHbmSynchronizeType synchronizedSpace = (JaxbHbmSynchronizeType) content;
+		else if ( content instanceof JaxbHbmSynchronizeType synchronizedSpace ) {
 			queryBuilder.addSynchronizedQuerySpace( synchronizedSpace.getTable() );
 		}
 		else if ( content instanceof JaxbHbmNativeQueryScalarReturnType ) {

hibernate-core/src/main/java/org/hibernate/boot/models/annotations/internal/SequenceGeneratorJpaAnnotation.java

@@ -32,8 +32,8 @@ public SequenceGeneratorJpaAnnotation(SourceModelBuildingContext modelContext) {
 	/**
 	 * Used in creating named, defaulted annotation instances.  Generally this
 	 * is a situation where we have:<ol>
-	 *     <li>{@linkplain GeneratedValue#strategy()} set to {@linkplain jakarta.persistence.GenerationType#SEQUENCE}</li>
-	 *     <li>{@linkplain GeneratedValue#generator()} set to a non-empty String, but with no matching {@linkplain SequenceGenerator}</li>
+	 *     <li>{@linkplain jakarta.persistence.GeneratedValue#strategy()} set to {@linkplain jakarta.persistence.GenerationType#SEQUENCE}</li>
+	 *     <li>{@linkplain jakarta.persistence.GeneratedValue#generator()} set to a non-empty String, but with no matching {@linkplain SequenceGenerator}</li>
 	 * </ol>
 	 */
 	public SequenceGeneratorJpaAnnotation(String name, SourceModelBuildingContext modelContext) {

hibernate-core/src/main/java/org/hibernate/boot/models/annotations/internal/TableGeneratorJpaAnnotation.java

@@ -47,8 +47,8 @@ public TableGeneratorJpaAnnotation(SourceModelBuildingContext modelContext) {
 	/**
 	 * Used in creating named, defaulted annotation instances.  Generally this
 	 * is a situation where we have:<ol>
-	 *     <li>{@linkplain GeneratedValue#strategy()} set to {@linkplain jakarta.persistence.GenerationType#TABLE}</li>
-	 *     <li>{@linkplain GeneratedValue#generator()} set to a non-empty String, but with no matching {@linkplain TableGenerator}</li>
+	 *     <li>{@linkplain jakarta.persistence.GeneratedValue#strategy()} set to {@linkplain jakarta.persistence.GenerationType#TABLE}</li>
+	 *     <li>{@linkplain jakarta.persistence.GeneratedValue#generator()} set to a non-empty String, but with no matching {@linkplain TableGenerator}</li>
 	 * </ol>
 	 */
 	public TableGeneratorJpaAnnotation(String name, SourceModelBuildingContext modelContext) {

hibernate-core/src/main/java/org/hibernate/boot/query/AbstractNamedQueryBuilder.java

@@ -12,6 +12,7 @@
 import org.hibernate.LockOptions;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.hibernate.models.spi.AnnotationTarget;
 
 /**
  * @author Steve Ebersole
@@ -36,14 +37,21 @@ public abstract class AbstractNamedQueryBuilder<R, T extends AbstractNamedQueryB
 
 	private Map<String, Object> hints;
 
-	public AbstractNamedQueryBuilder(String name) {
+	private final AnnotationTarget location;
+
+	public AbstractNamedQueryBuilder(String name, AnnotationTarget location) {
 		this.name = name;
+		this.location = location;
 	}
 
 	public String getName() {
 		return name;
 	}
 
+	AnnotationTarget getLocation() {
+		return location;
+	}
+
 	protected abstract T getThis();
 
 	public T setResultClass(Class<R> resultClass) {