HHH-18745 Avoid resolving unnecessary table references for subtypes

Also, handle type expressions in case statements like we do for
comparison logic.

Author: mbellade

hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java

@@ -3170,10 +3170,6 @@ else if ( useKind == EntityNameUse.UseKind.PROJECTION ) {
 						subType.getEntityName(),
 						(s, existingUse) -> finalEntityNameUse.stronger( existingUse )
 				);
-				actualTableGroup.resolveTableReference(
-						null,
-						subType.getEntityPersister().getMappedTableDetails().getTableName()
-				);
 			}
 		}
 	}
@@ -7141,6 +7137,8 @@ public CaseSimpleExpression visitSimpleCaseExpression(SqmCaseSimple<?, ?> expres
 			inferrableTypeAccessStack.push( () -> fixtureType );
 			final Expression checkValue = (Expression) whenFragment.getCheckValue().accept( this );
 			inferrableTypeAccessStack.pop();
+			handleTypeInCaseExpression( fixture, checkValue );
+
 			final MappingModelExpressible<?> alreadyKnown = resolved;
 			inferrableTypeAccessStack.push(
 					() -> alreadyKnown == null && inferenceSupplier != null ? inferenceSupplier.get() : alreadyKnown
@@ -7176,6 +7174,42 @@ public CaseSimpleExpression visitSimpleCaseExpression(SqmCaseSimple<?, ?> expres
 		);
 	}
 
+	private void handleTypeInCaseExpression(Expression fixture, Expression checkValue) {
+		if ( fixture instanceof DiscriminatorPathInterpretation<?> ) {
+			final DiscriminatorPathInterpretation<?> typeExpression = (DiscriminatorPathInterpretation<?>) fixture;
+			final TableGroup tableGroup = getFromClauseIndex().getTableGroup( typeExpression.getNavigablePath().getParent() );
+			final MappingType partMappingType = tableGroup.getModelPart().getPartMappingType();
+			if ( !(partMappingType instanceof EntityMappingType) ) {
+				return;
+			}
+			final EntityMappingType entityMappingType = (EntityMappingType) partMappingType;
+			if ( entityMappingType.getDiscriminatorMapping().hasPhysicalColumn() ) {
+				// If the entity type has a physical type column we only need to register an expression
+				// usage for the root type to prevent pruning the table where the discriminator is found
+				registerEntityNameUsage(
+						tableGroup,
+						EntityNameUse.EXPRESSION,
+						entityMappingType.getRootEntityDescriptor().getEntityName()
+				);
+			}
+			else if ( checkValue instanceof EntityTypeLiteral ) {
+				// Register an expression type usage for the literal subtype to prevent pruning its table group
+				registerEntityNameUsage(
+						tableGroup,
+						EntityNameUse.EXPRESSION,
+						( (EntityTypeLiteral) checkValue ).getEntityTypeDescriptor().getEntityName()
+				);
+			}
+			else {
+				// We have to assume all types are possible and can't do optimizations
+				registerEntityNameUsage( tableGroup, EntityNameUse.EXPRESSION, entityMappingType.getEntityName() );
+				for ( EntityMappingType subMappingType : entityMappingType.getSubMappingTypes() ) {
+					registerEntityNameUsage( tableGroup, EntityNameUse.EXPRESSION, subMappingType.getEntityName() );
+				}
+			}
+		}
+	}
+
 	@Override
 	public CaseSearchedExpression visitSearchedCaseExpression(SqmCaseSearched<?> expression) {
 		final List<CaseSearchedExpression.WhenFragment> whenFragments = new ArrayList<>( expression.getWhenFragments().size() );

hibernate-core/src/test/java/org/hibernate/orm/test/inheritance/discriminator/JoinedInheritanceDiscriminatorSelectionTest.java

@@ -141,28 +141,28 @@ public void testSelectInstance(SessionFactoryScope scope) {
 		inspector.clear();
 
 		scope.inTransaction( session -> {
-			// With type filters we still join all subclasses when selecting the entity instance
+			// With type filters we still join all subclasses that have properties when selecting the entity instance
 			// because we are not aware of the type restriction when processing the selection
 
 			assertThat( session.createQuery(
 					"from ParentEntity p where type(p) = ParentEntity",
 					ParentEntity.class
 			).getResultList() ).hasSize( 1 );
-			inspector.assertNumberOfJoins( 0, 3 );
+			inspector.assertNumberOfJoins( 0, 2 );
 			inspector.clear();
 
 			assertThat( session.createQuery(
 					"from ParentEntity p where type(p) = ChildA",
 					ParentEntity.class
 			).getResultList() ).hasSize( 1 );
-			inspector.assertNumberOfJoins( 0, 3 );
+			inspector.assertNumberOfJoins( 0, 2 );
 			inspector.clear();
 
 			assertThat( session.createQuery(
 					"from ParentEntity p where type(p) = SubChildA",
 					ParentEntity.class
 			).getResultList() ).hasSize( 1 );
-			inspector.assertNumberOfJoins( 0, 3 );
+			inspector.assertNumberOfJoins( 0, 2 );
 			inspector.clear();
 
 			// With treat() we only join the needed subclasses