HHH-18610 "SQLGrammarException: Unable to find column position by name" when using Single Table Inheritance with a strict JDBC driver such as PostgreSQL

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

@@ -13,6 +13,7 @@
 import jakarta.persistence.EmbeddedId;
 import jakarta.persistence.Id;
 import jakarta.persistence.IdClass;
+import org.hibernate.sql.results.graph.Fetchable;
 
 
 /**
@@ -22,7 +23,7 @@
  * @see EmbeddedId
  * @see Nature
  */
-public interface EntityIdentifierMapping extends ValuedModelPart {
+public interface EntityIdentifierMapping extends ValuedModelPart, Fetchable {
 
 	String ID_ROLE_NAME = "{id}";
 	String LEGACY_ID_NAME = "id";

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

@@ -21,6 +21,7 @@
 import org.hibernate.metamodel.mapping.PluralAttributeMapping;
 import org.hibernate.metamodel.model.domain.BasicDomainType;
 import org.hibernate.spi.NavigablePath;
+import org.hibernate.sql.results.graph.Fetchable;
 import org.hibernate.transform.ResultTransformer;
 import org.hibernate.type.BasicTypeReference;
 
@@ -504,6 +505,8 @@ interface FetchReturn extends ResultNode {
 
 		String getOwnerAlias();
 
+		Fetchable getFetchable();
+
 		String getFetchableName();
 
 		/**

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

@@ -30,6 +30,7 @@
 public class FetchMementoHbmStandard implements FetchMemento, FetchMemento.Parent {
 
 	private static final String ELEMENT_PREFIX = "element.";
+	private static final int ELEMENT_PREFIX_LENGTH = 8;
 
 	public interface FetchParentMemento {
 		NavigablePath getNavigablePath();
@@ -74,55 +75,110 @@ public FetchBuilder resolve(
 			Parent parent,
 			Consumer<String> querySpaceConsumer,
 			ResultSetMappingResolutionContext context) {
-		final Map<String, FetchBuilder> fetchBuilderMap = new HashMap<>();
-		fetchMementoMap.forEach(
-				(attrName, fetchMemento) -> fetchBuilderMap.put(
-						attrName,
-						fetchMemento.resolve(this, querySpaceConsumer, context )
-				)
-		);
-		final DynamicResultBuilderEntityStandard resultBuilder;
-		if ( fetchable instanceof PluralAttributeMapping ) {
-			resultBuilder = new DynamicResultBuilderEntityStandard(
-					(EntityMappingType) ( (PluralAttributeMapping) fetchable ).getElementDescriptor().getPartMappingType(),
-					tableAlias,
-					navigablePath
-			);
-			FetchBuilder element = fetchBuilderMap.get( "element" );
-			if ( element != null ) {
-				if ( element instanceof DynamicFetchBuilder ) {
-					resultBuilder.addIdColumnAliases(
-							( (DynamicFetchBuilder) element ).getColumnAliases().toArray( new String[0] )
-					);
-				}
-				else {
-					resultBuilder.addIdColumnAliases(
-							( (CompleteFetchBuilderEntityValuedModelPart) element ).getColumnAliases().toArray( new String[0] )
-					);
-				}
-			}
-			FetchBuilder index = fetchBuilderMap.get( "index" );
-			if ( index != null ) {
-				resultBuilder.addFetchBuilder( CollectionPart.Nature.INDEX.getName(), index );
-			}
-			for ( Map.Entry<String, FetchBuilder> entry : fetchBuilderMap.entrySet() ) {
-				if ( entry.getKey().startsWith( ELEMENT_PREFIX ) ) {
-					resultBuilder.addFetchBuilder( entry.getKey().substring( ELEMENT_PREFIX.length() ), entry.getValue() );
-				}
-			}
+		if ( fetchable instanceof PluralAttributeMapping pluralAttributeMapping ) {
+			return resolve( pluralAttributeMapping, querySpaceConsumer, context );
 		}
 		else {
-			resultBuilder = new DynamicResultBuilderEntityStandard(
-					( (ToOneAttributeMapping) fetchable ).getEntityMappingType(),
-					tableAlias,
-					navigablePath
-			);
-			fetchBuilderMap.forEach( resultBuilder::addFetchBuilder );
+			return resolve( (ToOneAttributeMapping) fetchable, querySpaceConsumer, context );
 		}
+	}
+
+	private FetchBuilder resolve(
+			PluralAttributeMapping pluralAttributeMapping,
+			Consumer<String> querySpaceConsumer,
+			ResultSetMappingResolutionContext context) {
+		final DynamicResultBuilderEntityStandard resultBuilder;
+		EntityMappingType partMappingType = (EntityMappingType) pluralAttributeMapping.getElementDescriptor()
+				.getPartMappingType();
+		resultBuilder = new DynamicResultBuilderEntityStandard(
+				partMappingType,
+				tableAlias,
+				navigablePath
+		);
+		final Map<Fetchable, FetchBuilder> fetchBuilderMap = new HashMap<>();
+		fetchMementoMap.forEach(
+				(attrName, fetchMemento) -> {
+					final FetchBuilder fetchBuilder = fetchMemento.resolve( this, querySpaceConsumer, context );
+
+					if ( attrName.equals( "element" ) ) {
+						if ( fetchBuilder instanceof DynamicFetchBuilder dynamicFetchBuilder ) {
+							resultBuilder.addIdColumnAliases(
+									dynamicFetchBuilder.getColumnAliases().toArray( new String[0] )
+							);
+						}
+						else {
+							resultBuilder.addIdColumnAliases(
+									((CompleteFetchBuilderEntityValuedModelPart) fetchBuilder).getColumnAliases()
+											.toArray( new String[0] )
+							);
+						}
+						fetchBuilderMap.put(
+								pluralAttributeMapping.getElementDescriptor(),
+								fetchBuilder
+						);
+					}
+					else if ( attrName.equals( "index" ) ) {
+						final CollectionPart indexDescriptor = pluralAttributeMapping.getIndexDescriptor();
+						resultBuilder.addFetchBuilder( indexDescriptor, fetchBuilder );
+						fetchBuilderMap.put(
+								indexDescriptor,
+								fetchBuilder
+						);
+					}
+					else if ( attrName.startsWith( ELEMENT_PREFIX ) ) {
+						final Fetchable attributeMapping = (Fetchable) partMappingType.findByPath(
+								attrName.substring( ELEMENT_PREFIX_LENGTH ) );
+						resultBuilder.addFetchBuilder( attributeMapping, fetchBuilder );
+						fetchBuilderMap.put(
+								attributeMapping,
+								fetchBuilder
+						);
+					}
+					else {
+						final Fetchable attributeMapping = (Fetchable) partMappingType.findByPath( attrName );
+						resultBuilder.addFetchBuilder( attributeMapping, fetchBuilder );
+						fetchBuilderMap.put(
+								attributeMapping,
+								fetchBuilder
+						);
+					}
+				}
+		);
+		return new DynamicFetchBuilderLegacy(
+				tableAlias,
+				ownerTableAlias,
+				fetchable,
+				keyColumnNames,
+				fetchBuilderMap,
+				resultBuilder
+		);
+	}
+
+	private FetchBuilder resolve(
+			ToOneAttributeMapping toOneAttributeMapping,
+			Consumer<String> querySpaceConsumer,
+			ResultSetMappingResolutionContext context) {
+		final Map<Fetchable, FetchBuilder> fetchBuilderMap = new HashMap<>();
+		fetchMementoMap.forEach(
+				(attrName, fetchMemento) ->
+						fetchBuilderMap.put(
+								(Fetchable) toOneAttributeMapping.findSubPart( attrName ),
+								fetchMemento.resolve( this, querySpaceConsumer, context )
+						)
+		);
+		final DynamicResultBuilderEntityStandard resultBuilder;
+		resultBuilder = new DynamicResultBuilderEntityStandard(
+				toOneAttributeMapping.getEntityMappingType(),
+				tableAlias,
+				navigablePath
+		);
+		fetchBuilderMap.forEach( (fetchable, fetchBuilder) ->
+				resultBuilder.addFetchBuilder( fetchable, fetchBuilder )
+		);
 		return new DynamicFetchBuilderLegacy(
 				tableAlias,
 				ownerTableAlias,
-				fetchable.getFetchableName(),
+				fetchable,
 				keyColumnNames,
 				fetchBuilderMap,
 				resultBuilder

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

@@ -23,6 +23,7 @@
 import org.hibernate.query.results.internal.complete.DelayedFetchBuilderBasicPart;
 import org.hibernate.query.results.internal.implicit.ImplicitFetchBuilderBasic;
 import org.hibernate.spi.NavigablePath;
+import org.hibernate.sql.results.graph.Fetchable;
 
 /**
  * @author Steve Ebersole
@@ -70,13 +71,13 @@ public ResultBuilderEntityValued resolve(
 			}
 		}
 
-		final HashMap<String, FetchBuilder> explicitFetchBuilderMap = new HashMap<>();
+		final HashMap<Fetchable, FetchBuilder> explicitFetchBuilderMap = new HashMap<>();
 
 		// If there are no explicit fetches, we don't register DELAYED builders to get implicit fetching of all basic fetchables
 		if ( !explicitFetchMementoMap.isEmpty() ) {
 			explicitFetchMementoMap.forEach(
 					(relativePath, fetchMemento) -> explicitFetchBuilderMap.put(
-							relativePath,
+							(Fetchable) entityDescriptor.findByPath( relativePath ),
 							fetchMemento.resolve( this, querySpaceConsumer, context )
 					)
 			);
@@ -87,13 +88,13 @@ public ResultBuilderEntityValued resolve(
 					attributeMapping -> {
 						final BasicValuedModelPart basicPart = attributeMapping.asBasicValuedModelPart();
 						if ( basicPart != null ) {
-							final Function<String, FetchBuilder> fetchBuilderCreator = k -> new DelayedFetchBuilderBasicPart(
-									navigablePath.append( k ),
+							final Function<Fetchable, FetchBuilder> fetchBuilderCreator = k -> new DelayedFetchBuilderBasicPart(
+									navigablePath.append( k.getFetchableName() ),
 									basicPart,
 									isEnhancedForLazyLoading
 							);
 							explicitFetchBuilderMap.computeIfAbsent(
-									attributeMapping.getFetchableName(),
+									attributeMapping,
 									fetchBuilderCreator
 							);
 						}

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

@@ -10,15 +10,16 @@
 
 import org.hibernate.LockMode;
 import org.hibernate.metamodel.mapping.EntityMappingType;
+import org.hibernate.query.results.FetchBuilderBasicValued;
 import org.hibernate.spi.NavigablePath;
 import org.hibernate.query.QueryLogging;
 import org.hibernate.query.named.FetchMemento;
 import org.hibernate.query.named.FetchMementoBasic;
 import org.hibernate.query.named.ResultMementoEntity;
-import org.hibernate.query.results.FetchBuilderBasicValued;
 import org.hibernate.query.results.FetchBuilder;
 import org.hibernate.query.results.ResultBuilderEntityValued;
 import org.hibernate.query.results.internal.complete.CompleteResultBuilderEntityStandard;
+import org.hibernate.sql.results.graph.Fetchable;
 
 /**
  * @author Steve Ebersole
@@ -64,11 +65,11 @@ public ResultBuilderEntityValued resolve(
 				? (FetchBuilderBasicValued) discriminatorMemento.resolve( this, querySpaceConsumer, context )
 				: null;
 
-		final HashMap<String, FetchBuilder> fetchBuilderMap = new HashMap<>();
+		final HashMap<Fetchable, FetchBuilder> fetchBuilderMap = new HashMap<>();
 
 		fetchMementoMap.forEach(
 				(attrName, fetchMemento) -> fetchBuilderMap.put(
-						attrName,
+						(Fetchable) entityDescriptor.findByPath( attrName ),
 						fetchMemento.resolve(this, querySpaceConsumer, context )
 				)
 		);

hibernate-core/src/main/java/org/hibernate/query/results/FetchBuilder.java

@@ -9,6 +9,7 @@
 import org.hibernate.sql.results.graph.DomainResultCreationState;
 import org.hibernate.sql.results.graph.Fetch;
 import org.hibernate.sql.results.graph.FetchParent;
+import org.hibernate.sql.results.graph.Fetchable;
 import org.hibernate.sql.results.jdbc.spi.JdbcValuesMetadata;
 
 import java.util.function.BiConsumer;
@@ -33,7 +34,7 @@ Fetch buildFetch(
 			JdbcValuesMetadata jdbcResultsMetadata,
 			DomainResultCreationState domainResultCreationState);
 
-	default void visitFetchBuilders(BiConsumer<String, FetchBuilder> consumer) {
+	default void visitFetchBuilders(BiConsumer<Fetchable, FetchBuilder> consumer) {
 	}
 
 	FetchBuilder cacheKeyInstance();

hibernate-core/src/main/java/org/hibernate/query/results/LegacyFetchBuilder.java

@@ -4,6 +4,8 @@
  */
 package org.hibernate.query.results;
 
+import org.hibernate.sql.results.graph.Fetchable;
+
 /**
  * Specialized FetchBuilder implementations which handle building fetches defined via:<ul>
  *     <li>{@code hbm.xml} definitions</li>
@@ -30,4 +32,6 @@ public interface LegacyFetchBuilder extends FetchBuilder {
 
 	@Override
 	LegacyFetchBuilder cacheKeyInstance();
+
+	Fetchable getFetchable();
 }

hibernate-core/src/main/java/org/hibernate/query/results/ResultBuilder.java

@@ -7,6 +7,7 @@
 import org.hibernate.Incubating;
 import org.hibernate.sql.results.graph.DomainResult;
 import org.hibernate.sql.results.graph.DomainResultCreationState;
+import org.hibernate.sql.results.graph.Fetchable;
 import org.hibernate.sql.results.jdbc.spi.JdbcValuesMetadata;
 
 import java.util.function.BiConsumer;
@@ -46,6 +47,6 @@ DomainResult<?> buildResult(
 
 	ResultBuilder cacheKeyInstance();
 
-	default void visitFetchBuilders(BiConsumer<String, FetchBuilder> consumer) {
+	default void visitFetchBuilders(BiConsumer<Fetchable, FetchBuilder> consumer) {
 	}
 }

hibernate-core/src/main/java/org/hibernate/query/results/internal/Builders.java

@@ -240,8 +240,8 @@ public static DynamicResultBuilderEntityCalculated entityCalculated(
 		return new DynamicResultBuilderEntityCalculated( entityMapping, tableAlias, explicitLockMode );
 	}
 
-	public static DynamicFetchBuilderLegacy fetch(String tableAlias, String ownerTableAlias, String joinPropertyName) {
-		return new DynamicFetchBuilderLegacy( tableAlias, ownerTableAlias, joinPropertyName, new ArrayList<>(), new HashMap<>() );
+	public static DynamicFetchBuilderLegacy fetch(String tableAlias, String ownerTableAlias, Fetchable fetchable) {
+		return new DynamicFetchBuilderLegacy( tableAlias, ownerTableAlias, fetchable, new ArrayList<>(), new HashMap<>() );
 	}
 
 	public static ResultBuilder resultClassBuilder(