Merge upstream main and add @Any annotation support

- Resolved conflicts with new FromExpressionFactory structure
- Added isAnyAnnotatedProperty() method to detect @Any annotations
- Modified getModelForPath() to handle @Any properties gracefully
- Updated ExpressionFactorySupport to treat null models as outer joins
- Integrated tests into QueryUtilsIntegrationTests

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

Author: academey

spring-data-jpa/src/main/java/org/springframework/data/jpa/provider/PersistenceProvider.java

@@ -332,6 +332,11 @@ public static PersistenceProvider fromEntityManagerFactory(EntityManagerFactory
 			} else if (AopUtils.isAopProxy(unwrapped)) {
 				unwrapped = (EntityManagerFactory) AopProxyUtils.getSingletonTarget(unwrapped);
 			}
+
+			if (unwrapped == null) {
+				throw new IllegalStateException(
+						"Unwrapping EntityManagerFactory from '%s' failed resulting in null".formatted(emf));
+			}
 		}
 
 		Class<?> entityManagerType = unwrapped.getClass();

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

@@ -240,7 +240,8 @@ default <S extends T, R> R findBy(PredicateSpecification<T> spec,
 	 * @since 3.0
 	 * @throws InvalidDataAccessApiUsageException if the query function returns the {@link FluentQuery} instance.
 	 */
-	<S extends T, R> R findBy(Specification<T> spec, Function<? super SpecificationFluentQuery<S>, R> queryFunction);
+	<S extends T, R extends @Nullable Object> R findBy(Specification<T> spec,
+			Function<? super SpecificationFluentQuery<S>, R> queryFunction);
 
 	/**
 	 * Extension to {@link FetchableFluentQuery} allowing slice results and pagination with a custom count

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/AotMetamodel.java

@@ -91,7 +91,7 @@ public void addTransformer(ClassTransformer classTransformer) {
 
 		this.entityManagerFactory = init(() -> {
 
-			managedTypes.stream().forEach(persistenceUnitInfo::addManagedClassName);
+			managedTypes.forEach(persistenceUnitInfo::addManagedClassName);
 
 			persistenceUnitInfo.setPersistenceProviderClassName(HibernatePersistenceProvider.class.getName());
 
@@ -104,7 +104,7 @@ public List<String> getManagedClassNames() {
 
 				@Override
 				public URL getPersistenceUnitRootUrl() {
-					return persistenceUnitRootUrl;
+					return persistenceUnitRootUrl != null ? persistenceUnitRootUrl : super.getPersistenceUnitRootUrl();
 				}
 
 			};

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/JpaCodeBlocks.java

@@ -281,7 +281,9 @@ private CodeBlock applyRewrite(@Nullable String sort, @Nullable String dynamicRe
 			return builder.build();
 		}
 
-		private CodeBlock applyLimits(boolean exists, String pageable) {
+		private CodeBlock applyLimits(boolean exists, @Nullable String pageable) {
+
+			Assert.notNull(queries, "Queries must not be null");
 
 			Builder builder = CodeBlock.builder();
 

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/QueriesFactory.java

@@ -25,6 +25,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
 import java.util.function.Function;
@@ -99,7 +100,7 @@ private NamedQueries getNamedQueries(@Nullable RepositoryConfigurationSource con
 				PropertiesBasedNamedQueriesFactoryBean factoryBean = new PropertiesBasedNamedQueriesFactoryBean();
 				factoryBean.setLocations(resolver.getResources(location));
 				factoryBean.afterPropertiesSet();
-				return factoryBean.getObject();
+				return Objects.requireNonNull(factoryBean.getObject());
 			} catch (IOException e) {
 				throw new RuntimeException(e);
 			}

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

@@ -97,7 +97,7 @@ public QueryProvider rewrite(QueryEnhancer.QueryRewriteInformation rewriteInform
 
 	@Override
 	public PreprocessedQuery getQuery() {
-		return null;
+		throw new UnsupportedOperationException();
 	}
 
 	@Override

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

@@ -0,0 +1,202 @@
+/*
+ * Copyright 2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.jpa.repository.query;
+
+import static jakarta.persistence.metamodel.Attribute.PersistentAttributeType.*;
+
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.metamodel.Attribute;
+import jakarta.persistence.metamodel.Bindable;
+import jakarta.persistence.metamodel.ManagedType;
+import jakarta.persistence.metamodel.PluralAttribute;
+import jakarta.persistence.metamodel.SingularAttribute;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Member;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jspecify.annotations.Nullable;
+
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.data.mapping.PropertyPath;
+import org.springframework.util.StringUtils;
+
+/**
+ * Support class to build expression factories for JPA query creation.
+ *
+ * @author Mark Paluch
+ * @since 4.0
+ */
+class ExpressionFactorySupport {
+
+	static final Map<Attribute.PersistentAttributeType, @Nullable Class<? extends Annotation>> ASSOCIATION_TYPES;
+
+	static {
+		Map<Attribute.PersistentAttributeType, @Nullable Class<? extends Annotation>> persistentAttributeTypes = new HashMap<>();
+		persistentAttributeTypes.put(ONE_TO_ONE, OneToOne.class);
+		persistentAttributeTypes.put(ONE_TO_MANY, null);
+		persistentAttributeTypes.put(MANY_TO_ONE, ManyToOne.class);
+		persistentAttributeTypes.put(MANY_TO_MANY, null);
+		persistentAttributeTypes.put(ELEMENT_COLLECTION, null);
+
+		ASSOCIATION_TYPES = Collections.unmodifiableMap(persistentAttributeTypes);
+	}
+
+	/**
+	 * Checks if this attribute requires an outer join. This is the case e.g. if it hadn't already been fetched with an
+	 * inner join and if it's an optional association, and if previous paths has already required outer joins. It also
+	 * ensures outer joins are used even when Hibernate defaults to inner joins (HHH-12712 and HHH-12999).
+	 *
+	 * @param resolver the {@link ModelPathResolver} to check for the model.
+	 * @param property the property path
+	 * @param isForSelection is the property navigated for the selection or ordering part of the query? if true, we need
+	 *          to generate an explicit outer join in order to prevent Hibernate to use an inner join instead. see
+	 *          https://hibernate.atlassian.net/browse/HHH-12999
+	 * @param hasRequiredOuterJoin has a parent already required an outer join?
+	 * @param isLeafProperty is leaf property
+	 * @param isRelationshipId whether property path refers to relationship id
+	 * @return whether an outer join is to be used for integrating this attribute in a query.
+	 */
+	public boolean requiresOuterJoin(ModelPathResolver resolver, PropertyPath property, boolean isForSelection,
+			boolean hasRequiredOuterJoin, boolean isLeafProperty, boolean isRelationshipId) {
+
+		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;
+		}
+
+		// not a persistent attribute type association (@OneToOne, @ManyToOne)
+		if (!ASSOCIATION_TYPES.containsKey(attribute.getPersistentAttributeType())) {
+			return false;
+		}
+
+		boolean isCollection = attribute.isCollection();
+		// if this path is an optional one to one attribute navigated from the not owning side we also need an
+		// explicit outer join to avoid https://hibernate.atlassian.net/browse/HHH-12712
+		// and https://github.com/eclipse-ee4j/jpa-api/issues/170
+		boolean isInverseOptionalOneToOne = ONE_TO_ONE == attribute.getPersistentAttributeType()
+				&& StringUtils.hasText(getAnnotationProperty(attribute, "mappedBy", ""));
+
+		if ((isLeafProperty || isRelationshipId) && !isForSelection && !isCollection && !isInverseOptionalOneToOne
+				&& !hasRequiredOuterJoin) {
+			return false;
+		}
+
+		return hasRequiredOuterJoin || getAnnotationProperty(attribute, "optional", true);
+	}
+
+	/**
+	 * Checks if this property path is referencing to relationship id.
+	 *
+	 * @param resolver the {@link ModelPathResolver resolver}.
+	 * @param property the property path.
+	 * @return whether in a query is relationship id.
+	 */
+	public boolean isRelationshipId(ModelPathResolver resolver, PropertyPath property) {
+
+		if (!property.hasNext()) {
+			return false;
+		}
+
+		Bindable<?> bindable = resolver.resolveNext(property);
+		return bindable instanceof SingularAttribute<?, ?> sa && sa.isId();
+	}
+
+	@SuppressWarnings("unchecked")
+	private static <T> T getAnnotationProperty(Attribute<?, ?> attribute, String propertyName, T defaultValue) {
+
+		Class<? extends Annotation> associationAnnotation = ASSOCIATION_TYPES.get(attribute.getPersistentAttributeType());
+
+		if (associationAnnotation == null) {
+			return defaultValue;
+		}
+
+		Member member = attribute.getJavaMember();
+
+		if (!(member instanceof AnnotatedElement annotatedMember)) {
+			return defaultValue;
+		}
+
+		Annotation annotation = AnnotationUtils.getAnnotation(annotatedMember, associationAnnotation);
+		if (annotation == null) {
+			return defaultValue;
+		}
+
+		T value = (T) AnnotationUtils.getValue(annotation, propertyName);
+		return value != null ? value : defaultValue;
+	}
+
+	/**
+	 * Required for EclipseLink: we try to avoid using from.get as EclipseLink produces an inner join regardless of which
+	 * join operation is specified next
+	 *
+	 * @see <a href=
+	 *      "https://bugs.eclipse.org/bugs/show_bug.cgi?id=413892">https://bugs.eclipse.org/bugs/show_bug.cgi?id=413892</a>
+	 * @param model
+	 * @return
+	 */
+	static @Nullable ManagedType<?> getManagedTypeForModel(@Nullable Object model) {
+
+		if (model instanceof ManagedType<?> managedType) {
+			return managedType;
+		}
+
+		if (model instanceof PluralAttribute<?, ?, ?> pa) {
+			return pa.getElementType() instanceof ManagedType<?> managedType ? managedType : null;
+		}
+
+		if (!(model instanceof SingularAttribute<?, ?> singularAttribute)) {
+			return null;
+		}
+
+		return singularAttribute.getType() instanceof ManagedType<?> managedType ? managedType : null;
+	}
+
+	public interface ModelPathResolver {
+
+		/**
+		 * Resolve the {@link Bindable} for the given {@link PropertyPath}.
+		 *
+		 * @param propertyPath
+		 * @return
+		 */
+		@Nullable
+		Bindable<?> resolve(PropertyPath propertyPath);
+
+		/**
+		 * Resolve the next {@link Bindable} for the given {@link PropertyPath}. Requires the {@link PropertyPath#hasNext()
+		 * to have a next item}.
+		 *
+		 * @param propertyPath
+		 * @return
+		 */
+		@Nullable
+		Bindable<?> resolveNext(PropertyPath propertyPath);
+
+	}
+
+}

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

@@ -142,7 +142,7 @@ public QueryTokenStream visitJoinFunctionCall(HqlParser.JoinFunctionCallContext
 		QueryTokenStream tokens = super.visitJoinFunctionCall(ctx);
 
 		if (ctx.variable() != null && !tokens.isEmpty()) {
-			transformerSupport.registerAlias(tokens.getLast());
+			transformerSupport.registerAlias(tokens.getRequiredLast());
 		}
 
 		return tokens;

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

@@ -357,7 +357,7 @@ private JpqlQueryBuilder.Select doSelect(Sort sort) {
 		}
 	}
 
-	private JpqlQueryBuilder.Expression getDistanceExpression() {
+	private JpqlQueryBuilder.@Nullable Expression getDistanceExpression() {
 
 		DistanceFunction distanceFunction = DISTANCE_FUNCTIONS.get(provider.getScoringFunction());
 

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

@@ -1019,16 +1019,6 @@ public interface Origin {
 
 	}
 
-	/**
-	 * An origin that is used to select data from. selection origins are used with paths to define where a path is
-	 * anchored.
-	 */
-	public interface Bindable {
-
-		boolean isRoot();
-
-	}
-
 	/**
 	 * The root entity.
 	 */