Avoid DTO Constructor Expression rewriting for selection of nested properties.

We back off from rewriting String-based queries to use DTO Constructor expressions if the query selects a property that is assignable to the return type.

Closes #3862

Author: mp911de

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

@@ -18,20 +18,26 @@
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.Query;
 
+import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.jspecify.annotations.Nullable;
 
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.expression.ValueEvaluationContextProvider;
 import org.springframework.data.jpa.repository.QueryRewriter;
+import org.springframework.data.mapping.PropertyPath;
+import org.springframework.data.mapping.PropertyReferenceException;
 import org.springframework.data.repository.query.ResultProcessor;
 import org.springframework.data.repository.query.ReturnedType;
 import org.springframework.data.repository.query.ValueExpressionDelegate;
 import org.springframework.data.util.Lazy;
 import org.springframework.util.Assert;
 import org.springframework.util.ConcurrentLruCache;
+import org.springframework.util.StringUtils;
 
 /**
  * Base class for {@link String} based JPA queries.
@@ -49,6 +55,7 @@
 abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 
 	private final EntityQuery query;
+	private final Map<Class<?>, Boolean> knownProjections = new ConcurrentHashMap<>();
 	private final Lazy<ParametrizedQuery> countQuery;
 	private final ValueExpressionDelegate valueExpressionDelegate;
 	private final QueryRewriter queryRewriter;
@@ -132,7 +139,7 @@ public Query doCreateQuery(JpaParametersParameterAccessor accessor) {
 
 		Sort sort = accessor.getSort();
 		ResultProcessor processor = getQueryMethod().getResultProcessor().withDynamicProjection(accessor);
-		ReturnedType returnedType = processor.getReturnedType();
+		ReturnedType returnedType = getReturnedType(processor);
 		QueryProvider sortedQuery = getSortedQuery(sort, returnedType);
 		Query query = createJpaQuery(sortedQuery, sort, accessor.getPageable(), returnedType);
 
@@ -141,6 +148,86 @@ public Query doCreateQuery(JpaParametersParameterAccessor accessor) {
 		return parameterBinder.get().bindAndPrepare(query, accessor);
 	}
 
+	/**
+	 * Post-process {@link ReturnedType} to determine if the query is projecting by checking the projection and property
+	 * assignability.
+	 *
+	 * @param processor
+	 * @return
+	 */
+	private ReturnedType getReturnedType(ResultProcessor processor) {
+
+		ReturnedType returnedType = processor.getReturnedType();
+		Class<?> returnedJavaType = processor.getReturnedType().getReturnedType();
+
+		if (query.isDefaultProjection() || !returnedType.isProjecting() || returnedJavaType.isInterface()
+				|| query.isNative()) {
+			return returnedType;
+		}
+
+		Boolean known = knownProjections.get(returnedJavaType);
+
+		if (known != null && known) {
+			return returnedType;
+		}
+
+		if ((known != null && !known) || returnedJavaType.isArray()) {
+			if (known == null) {
+				knownProjections.put(returnedJavaType, false);
+			}
+			return new NonProjectingReturnedType(returnedType);
+		}
+
+		String projectionToUse = query.<@Nullable String> doWithEnhancer(queryEnhancer -> {
+
+			String alias = queryEnhancer.detectAlias();
+			String projection = queryEnhancer.getProjection();
+
+			// we can handle single-column and no function projections here only
+			if (StringUtils.hasText(projection) && (projection.indexOf(',') != -1 || projection.indexOf('(') != -1)) {
+				return null;
+			}
+
+			if (StringUtils.hasText(alias) && StringUtils.hasText(projection)) {
+				alias = alias.trim();
+				projection = projection.trim();
+				if (projection.startsWith(alias + ".")) {
+					projection = projection.substring(alias.length() + 1);
+				}
+			}
+
+			int space = projection.indexOf(' ');
+
+			if (space != -1) {
+				projection = projection.substring(0, space);
+			}
+
+			return projection;
+		});
+
+		if (StringUtils.hasText(projectionToUse)) {
+
+			Class<?> propertyType;
+
+			try {
+				PropertyPath from = PropertyPath.from(projectionToUse, getQueryMethod().getEntityInformation().getJavaType());
+				propertyType = from.getLeafType();
+			} catch (PropertyReferenceException ignored) {
+				propertyType = null;
+			}
+
+			if (propertyType == null
+					|| (returnedJavaType.isAssignableFrom(propertyType) || propertyType.isAssignableFrom(returnedJavaType))) {
+				knownProjections.put(returnedJavaType, false);
+				return new NonProjectingReturnedType(returnedType);
+			} else {
+				knownProjections.put(returnedJavaType, true);
+			}
+		}
+
+		return returnedType;
+	}
+
 	QueryProvider getSortedQuery(Sort sort, ReturnedType returnedType) {
 		return querySortRewriter.getSorted(query, sort, returnedType);
 	}
@@ -355,4 +442,46 @@ public int hashCode() {
 			return result;
 		}
 	}
+
+	/**
+	 * Non-projecting {@link ReturnedType} wrapper that delegates to the original {@link ReturnedType} but always returns
+	 * {@code false} for {@link #isProjecting()}. This type is to indicate that this query is not projecting, even if the
+	 * original {@link ReturnedType} was because we e.g. select a nested property and do not want DTO constructor
+	 * expression rewriting to kick in.
+	 */
+	private static class NonProjectingReturnedType extends ReturnedType {
+
+		private final ReturnedType delegate;
+
+		NonProjectingReturnedType(ReturnedType delegate) {
+			super(delegate.getDomainType());
+			this.delegate = delegate;
+		}
+
+		@Override
+		public boolean isProjecting() {
+			return false;
+		}
+
+		@Override
+		public Class<?> getReturnedType() {
+			return delegate.getReturnedType();
+		}
+
+		@Override
+		public boolean needsCustomConstruction() {
+			return false;
+		}
+
+		@Override
+		@Nullable
+		public Class<?> getTypeToRead() {
+			return delegate.getTypeToRead();
+		}
+
+		@Override
+		public List<String> getInputProperties() {
+			return delegate.getInputProperties();
+		}
+	}
 }

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

@@ -16,6 +16,7 @@
 package org.springframework.data.jpa.repository.query;
 
 import java.util.List;
+import java.util.function.Function;
 
 import org.jspecify.annotations.Nullable;
 
@@ -46,6 +47,11 @@ class DefaultEntityQuery implements EntityQuery, DeclaredQuery {
 		this.queryEnhancer = queryEnhancerFactory.create(query);
 	}
 
+	@Override
+	public <T> T doWithEnhancer(Function<QueryEnhancer, T> function) {
+		return function.apply(queryEnhancer);
+	}
+
 	@Override
 	public boolean isNative() {
 		return query.isNative();

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

@@ -17,6 +17,7 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Function;
 
 import org.jspecify.annotations.Nullable;
 
@@ -33,6 +34,8 @@ enum EmptyIntrospectedQuery implements EntityQuery {
 
 	EmptyIntrospectedQuery() {}
 
+
+
 	@Override
 	public boolean hasParameterBindings() {
 		return false;
@@ -57,11 +60,21 @@ public List<ParameterBinding> getParameterBindings() {
 		return null;
 	}
 
+	@Override
+	public <T> T doWithEnhancer(Function<QueryEnhancer, T> function) {
+		return null;
+	}
+
 	@Override
 	public boolean hasConstructorExpression() {
 		return false;
 	}
 
+	@Override
+	public boolean isNative() {
+		return false;
+	}
+
 	@Override
 	public boolean isDefaultProjection() {
 		return false;

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

@@ -15,6 +15,8 @@
  */
 package org.springframework.data.jpa.repository.query;
 
+import java.util.function.Function;
+
 import org.jspecify.annotations.Nullable;
 
 /**
@@ -45,13 +47,27 @@ static EntityQuery create(DeclaredQuery query, QueryEnhancerSelector selector) {
 		return new DefaultEntityQuery(preparsed, enhancerFactory);
 	}
 
+	/**
+	 * Apply a {@link Function} to the query enhancer used by this query.
+	 *
+	 * @param function the callback function.
+	 * @return
+	 * @param <T>
+	 */
+	<T extends @Nullable Object> T doWithEnhancer(Function<QueryEnhancer, T> function);
+
 	/**
 	 * Returns whether the query is using a constructor expression.
 	 *
 	 * @since 1.10
 	 */
 	boolean hasConstructorExpression();
 
+	/**
+	 * @return whether the underlying query has at least one named parameter.
+	 */
+	boolean isNative();
+
 	/**
 	 * Returns whether the query uses the default projection, i.e. returns the main alias defined for the query.
 	 */

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

@@ -30,7 +30,7 @@
  * @see EntityQuery#create(DeclaredQuery, QueryEnhancerSelector)
  * @see TemplatedQuery#create(String, JpaQueryMethod, JpaQueryConfiguration)
  */
-interface ParametrizedQuery extends QueryProvider {
+public interface ParametrizedQuery extends QueryProvider {
 
 	/**
 	 * @return whether the underlying query has at least one parameter.

spring-data-jpa/src/test/java/org/springframework/data/jpa/domain/sample/Address.java

@@ -17,6 +17,8 @@
 
 import jakarta.persistence.Embeddable;
 
+import org.springframework.util.ObjectUtils;
+
 /**
  * @author Thomas Darimont
  */
@@ -52,4 +54,26 @@ public String getStreetName() {
 	public String getStreetNo() {
 		return streetNo;
 	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (!(o instanceof Address address)) {
+			return false;
+		}
+		if (!ObjectUtils.nullSafeEquals(country, address.country)) {
+			return false;
+		}
+		if (!ObjectUtils.nullSafeEquals(city, address.city)) {
+			return false;
+		}
+		if (!ObjectUtils.nullSafeEquals(streetName, address.streetName)) {
+			return false;
+		}
+		return ObjectUtils.nullSafeEquals(streetNo, address.streetNo);
+	}
+
+	@Override
+	public int hashCode() {
+		return ObjectUtils.nullSafeHash(country, city, streetName, streetNo);
+	}
 }

spring-data-jpa/src/test/java/org/springframework/data/jpa/domain/sample/Role.java

@@ -19,6 +19,8 @@
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.Id;
 
+import org.springframework.util.ObjectUtils;
+
 /**
  * Sample domain class representing roles. Mapped with XML.
  *
@@ -55,4 +57,17 @@ public String toString() {
 	public boolean isNew() {
 		return id == null;
 	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (!(o instanceof Role role)) {
+			return false;
+		}
+		return ObjectUtils.nullSafeEquals(id, role.id);
+	}
+
+	@Override
+	public int hashCode() {
+		return ObjectUtils.nullSafeHash(id);
+	}
 }

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

@@ -42,6 +42,7 @@
 import org.springframework.data.domain.Slice;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Window;
+import org.springframework.data.jpa.domain.sample.Address;
 import org.springframework.data.jpa.domain.sample.Role;
 import org.springframework.data.jpa.domain.sample.User;
 import org.springframework.data.jpa.provider.PersistenceProvider;
@@ -421,6 +422,11 @@ void dtoProjectionShouldApplyConstructorExpressionRewriting() {
 
 		assertThat(dtos).flatExtracting(UserRepository.UserExcerpt::firstname) //
 				.contains("Dave", "Carter", "Oliver August");
+
+		dtos = userRepository.findRecordProjectionWithFunctions();
+
+		assertThat(dtos).flatExtracting(UserRepository.UserExcerpt::lastname) //
+				.contains("matthews", "beauford");
 	}
 
 	@Test // GH-3076
@@ -441,6 +447,29 @@ void dynamicDtoProjection() {
 				.contains("Dave", "Carter", "Oliver August");
 	}
 
+	@Test // GH-3862
+	void shouldNotRewritePrimitiveSelectionToDtoProjection() {
+
+		oliver.setAge(28);
+		em.persist(oliver);
+
+		assertThat(userRepository.findAgeByAnnotatedQuery(oliver.getEmailAddress())).contains(28);
+	}
+
+	@Test // GH-3862
+	void shouldNotRewritePropertySelectionToDtoProjection() {
+
+		Address address = new Address("DE", "Dresden", "some street", "12345");
+		dave.setAddress(address);
+		userRepository.save(dave);
+		em.flush();
+		em.clear();
+
+		assertThat(userRepository.findAddressByAnnotatedQuery(dave.getEmailAddress())).contains(address);
+		assertThat(userRepository.findCityByAnnotatedQuery(dave.getEmailAddress())).contains("Dresden");
+		assertThat(userRepository.findRolesByAnnotatedQuery(dave.getEmailAddress())).contains(singer);
+	}
+
 	@Test // GH-3076
 	void dtoProjectionWithEntityAndAggregatedValue() {