HHH-18723 Support @SQLRestriction in class marked as @MappedSuperclass

Author: a-e-tsvetkov

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

@@ -330,19 +330,25 @@ private static SoftDelete extractSoftDelete(ClassDetails classDetails, MetadataB
 		if ( fromClass != null ) {
 			return fromClass;
 		}
+		SoftDelete fromSuper = extractAnnotationFromMappedSuperclass( classDetails, SoftDelete.class, sourceModelContext );
+		if ( fromSuper != null ) {
+			return fromSuper;
+		}
+		return extractFromPackage( SoftDelete.class, classDetails, context );
+	}
 
+	private static <A extends Annotation> A extractAnnotationFromMappedSuperclass(ClassDetails classDetails, Class<A> annotationClass, SourceModelBuildingContext sourceModelContext) {
 		ClassDetails classToCheck = classDetails.getSuperClass();
 		while ( classToCheck != null ) {
-			final SoftDelete fromSuper = classToCheck.getAnnotationUsage( SoftDelete.class, sourceModelContext );
+			final A fromSuper = classToCheck.getAnnotationUsage( annotationClass, sourceModelContext );
 			if ( fromSuper != null
 					&& classToCheck.hasAnnotationUsage( jakarta.persistence.MappedSuperclass.class, sourceModelContext ) ) {
 				return fromSuper;
 			}
 
 			classToCheck = classToCheck.getSuperClass();
 		}
-
-		return extractFromPackage( SoftDelete.class, classDetails, context );
+		return null;
 	}
 
 	private void handleCheckConstraints() {
@@ -1628,12 +1634,21 @@ public void bindConcreteProxy() {
 	}
 
 	public void bindWhere() {
-		final SQLRestriction restriction = getOverridableAnnotation( annotatedClass, SQLRestriction.class, context );
+		final SQLRestriction restriction = extractSQLRestriction( annotatedClass, context );
 		if ( restriction != null ) {
 			this.where = restriction.value();
 		}
 	}
 
+	private static SQLRestriction extractSQLRestriction(ClassDetails classDetails, MetadataBuildingContext context) {
+		final SourceModelBuildingContext sourceModelContext = context.getMetadataCollector().getSourceModelBuildingContext();
+		final SQLRestriction fromClass = classDetails.getAnnotationUsage( SQLRestriction.class, sourceModelContext );
+		if ( fromClass != null ) {
+			return fromClass;
+		}
+		return extractAnnotationFromMappedSuperclass( classDetails, SQLRestriction.class, sourceModelContext );
+	}
+
 	public void setWrapIdsInEmbeddedComponents(boolean wrapIdsInEmbeddedComponents) {
 		this.wrapIdsInEmbeddedComponents = wrapIdsInEmbeddedComponents;
 	}

hibernate-core/src/test/java/org/hibernate/orm/test/where/annotations/MappedSuperclassTest.java

@@ -0,0 +1,94 @@
+/*
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.orm.test.where.annotations;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.MappedSuperclass;
+import org.hibernate.annotations.SQLRestriction;
+import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
+import org.hibernate.testing.orm.junit.Jpa;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+@Jpa(
+		annotatedClasses = {
+				MappedSuperclassTest.Child.class,
+				MappedSuperclassTest.SubClass.class
+		}
+)
+public class MappedSuperclassTest {
+
+	@AfterEach
+	public void tearDown(EntityManagerFactoryScope scope) {
+		scope.inTransaction(
+				entityManager -> {
+					entityManager.createQuery( "delete from SubClass" ).executeUpdate();
+					entityManager.createQuery( "delete from Child" ).executeUpdate();
+				}
+		);
+	}
+
+	@Test
+	public void testFindParent(EntityManagerFactoryScope scope) {
+		scope.inTransaction(
+				entityManager -> {
+					Child child1 = new SubClass( 1L );
+					child1.flag = true;
+					entityManager.persist( child1 );
+
+					Child child2 = new Child( 2L );
+					child2.flag = false;
+					entityManager.persist( child2 );
+				}
+		);
+		scope.inTransaction(
+				entityManager -> {
+					List<Child> children = entityManager.createQuery( "select c from Child c", Child.class )
+							.getResultList();
+					assertThat( children.size() ).isEqualTo( 1 );
+				}
+		);
+	}
+
+	@Entity(name = "Child")
+	public static class Child extends Intermediate {
+		@Id
+		private Long id;
+
+		public Child() {
+		}
+
+		public Child(long id) {
+			this.id = id;
+		}
+	}
+
+	@Entity(name = "SubClass")
+	public static class SubClass extends Child {
+		public SubClass() {
+		}
+
+		public SubClass(long id) {
+			super( id );
+		}
+	}
+
+	public static class Intermediate extends Parent {
+	}
+
+	@MappedSuperclass
+	@SQLRestriction("flag = false")
+	public static class Parent {
+		public Parent() {
+		}
+
+		boolean flag;
+	}
+}