Support Hibernate @Any annotation in query derivation

Fixes #2318

Added support for Hibernate's @Any annotation in query derivation.
The issue was that @Any properties are not part of JPA metamodel,
causing IllegalArgumentException.

This fix uses reflection to detect @Any annotations and handles
them appropriately during query creation.

Signed-off-by: academey <[email protected]>

Author: academey

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/ExpressionFactorySupport.java

@@ -79,6 +79,12 @@ public boolean requiresOuterJoin(ModelPathResolver resolver, PropertyPath proper
 
 		Bindable<?> propertyPathModel = resolver.resolve(property);
 
+		// If propertyPathModel is null, it might be a @Any association
+		if (propertyPathModel == null) {
+			// For @Any associations or other non-metamodel properties, default to outer join
+			return true;
+		}
+
 		if (!(propertyPathModel instanceof Attribute<?, ?> attribute)) {
 			return false;
 		}

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/QueryUtils.java

@@ -789,6 +789,13 @@ <T> Expression<T> toExpressionRecursively(From<?, ?> from, PropertyPath property
 
 			boolean isLeafProperty = !property.hasNext();
 
+			// Check if this is a Hibernate @Any annotated property
+			if (isAnyAnnotatedProperty(from, property)) {
+				// For @Any associations, we need to handle them specially since they're not in the metamodel
+				// Simply return the path expression without further processing
+				return from.get(segment);
+			}
+
 			FromPathResolver resolver = new FromPathResolver(from);
 			boolean isRelationshipId = isRelationshipId(resolver, property);
 			boolean requiresOuterJoin = requiresOuterJoin(resolver, property, isForSelection, hasRequiredOuterJoin,
@@ -947,12 +954,58 @@ private static Bindable<?> getModelForPath(PropertyPath path, @Nullable ManagedT
 						return (Bindable<?>) managedType.getAttribute(segment);
 					} catch (IllegalArgumentException ex) {
 						// ManagedType may be erased for some vendor if the attribute is declared as generic
+						// or the attribute is not part of the metamodel (e.g., @Any annotation)
 					}
 				}
 
-				return (Bindable<?>) fallback.get().get(segment);
+				try {
+					return (Bindable<?>) fallback.get().get(segment);
+				} catch (IllegalArgumentException ex) {
+					// This can happen with @Any annotated properties as they're not in the metamodel
+					// Return null to indicate the property cannot be resolved through the metamodel
+					return null;
+				}
 			}
 		}
+
+		/**
+		 * Checks if the given property path represents a property annotated with Hibernate's @Any annotation.
+		 * This is necessary because @Any associations are not present in the JPA metamodel.
+		 *
+		 * @param from the root from which to resolve the property
+		 * @param property the property path to check
+		 * @return true if the property is annotated with @Any, false otherwise
+		 */
+		private static boolean isAnyAnnotatedProperty(From<?, ?> from, PropertyPath property) {
+
+			try {
+				Class<?> javaType = from.getJavaType();
+				String propertyName = property.getSegment();
+				
+				Member member = null;
+				try {
+					member = javaType.getDeclaredField(propertyName);
+				} catch (NoSuchFieldException ex) {
+					String capitalizedProperty = propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
+					try {
+						member = javaType.getDeclaredMethod("get" + capitalizedProperty);
+					} catch (NoSuchMethodException ex2) {
+						return false;
+					}
+				}
+				
+				if (member instanceof AnnotatedElement annotatedElement) {
+					for (Annotation annotation : annotatedElement.getAnnotations()) {
+						if (annotation.annotationType().getName().equals("org.hibernate.annotations.Any")) {
+							return true;
+						}
+					}
+				}
+			} catch (Exception ex) {
+				// If anything goes wrong, assume it's not an @Any property
+			}
+			return false;
+		}
 	}
 
 }

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/query/QueryUtilsIntegrationTests.java

@@ -45,6 +45,10 @@
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
+import org.hibernate.annotations.Any;
+import org.hibernate.annotations.AnyDiscriminator;
+import org.hibernate.annotations.AnyDiscriminatorValue;
+import org.hibernate.annotations.AnyKeyJavaClass;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mockito;
@@ -372,6 +376,36 @@ void queryUtilsConsidersNullPrecedence() {
 		}
 	}
 
+	@Test // GH-2318
+	void handlesHibernateAnyAnnotationWithoutThrowingException() {
+
+		doInMerchantContext((emf) -> {
+
+			CriteriaBuilder builder = emf.createEntityManager().getCriteriaBuilder();
+			CriteriaQuery<EntityWithAny> query = builder.createQuery(EntityWithAny.class);
+			Root<EntityWithAny> root = query.from(EntityWithAny.class);
+
+			// This would throw IllegalArgumentException without the fix
+			PropertyPath monitorObjectPath = PropertyPath.from("monitorObject", EntityWithAny.class);
+			assertThatNoException().isThrownBy(() -> QueryUtils.toExpressionRecursively(root, monitorObjectPath));
+		});
+	}
+
+	@Test // GH-2318
+	void doesNotCreateJoinForAnyAnnotatedProperty() {
+
+		doInMerchantContext((emf) -> {
+
+			CriteriaBuilder builder = emf.createEntityManager().getCriteriaBuilder();
+			CriteriaQuery<EntityWithAny> query = builder.createQuery(EntityWithAny.class);
+			Root<EntityWithAny> root = query.from(EntityWithAny.class);
+
+			QueryUtils.toExpressionRecursively(root, PropertyPath.from("monitorObject", EntityWithAny.class));
+
+			assertThat(root.getJoins()).isEmpty();
+		});
+	}
+
 	/**
 	 * This test documents an ambiguity in the JPA spec (or it's implementation in Hibernate vs EclipseLink) that we have
 	 * to work around in the test {@link #doesNotCreateJoinForOptionalAssociationWithoutFurtherNavigation()}. See also:
@@ -475,6 +509,38 @@ static class Credential {
 		String uid;
 	}
 
+	@Entity
+	@SuppressWarnings("unused")
+	static class EntityWithAny {
+
+		@Id String id;
+
+		@Any
+		@AnyDiscriminator // Default is STRING type
+		@AnyDiscriminatorValue(discriminator = "monitorable", entity = MonitorableEntity.class)
+		@AnyDiscriminatorValue(discriminator = "another", entity = AnotherMonitorableEntity.class)
+		@AnyKeyJavaClass(String.class)
+		@jakarta.persistence.JoinColumn(name = "monitor_object_id")
+		@jakarta.persistence.Column(name = "monitor_object_type")
+		Object monitorObject;
+	}
+
+	@Entity
+	@SuppressWarnings("unused")
+	static class MonitorableEntity {
+
+		@Id String id;
+		String name;
+	}
+
+	@Entity
+	@SuppressWarnings("unused")
+	static class AnotherMonitorableEntity {
+
+		@Id String id;
+		String code;
+	}
+
 	/**
 	 * A {@link PersistenceProviderResolver} that returns only a Hibernate {@link PersistenceProvider} and ignores others.
 	 *

spring-data-jpa/src/test/resources/META-INF/persistence.xml

@@ -106,6 +106,9 @@
 		<class>org.springframework.data.jpa.repository.query.QueryUtilsIntegrationTests$Address</class>
 		<class>org.springframework.data.jpa.repository.query.QueryUtilsIntegrationTests$Employee</class>
 		<class>org.springframework.data.jpa.repository.query.QueryUtilsIntegrationTests$Credential</class>
+		<class>org.springframework.data.jpa.repository.query.QueryUtilsIntegrationTests$EntityWithAny</class>
+		<class>org.springframework.data.jpa.repository.query.QueryUtilsIntegrationTests$MonitorableEntity</class>
+		<class>org.springframework.data.jpa.repository.query.QueryUtilsIntegrationTests$AnotherMonitorableEntity</class>
 		<exclude-unlisted-classes>true</exclude-unlisted-classes>
 		<properties>
 			<property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect" />