Translate projected properties of the fluent query API into a fetchgraph.

When a property path based projection is specified we still return the root entity.
But we do provide a fetchgraph.
The JPA implementation will (should) load only the specified attributes eagerly.
It most likely will also load all other attributes from all selected tables.

Once we have infrastructure in place for for multilevel projections the same approach can and should be used for those.
Currently this is not the case.

Closes #2329
See spring-projects/spring-data-commons#2420

Author: schauder

src/main/java/org/springframework/data/jpa/repository/support/DefaultProjector.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2021 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.support;
+
+import java.util.Set;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Subgraph;
+
+import org.springframework.lang.Nullable;
+
+import com.querydsl.jpa.impl.AbstractJPAQuery;
+
+/**
+ * Realizes projection by property path as fetchgraph hints.
+ *
+ * @author Jens Schauder
+ *
+ * @since 2.6
+ */
+class DefaultProjector implements Projector {
+
+	private final EntityManager entityManager;
+
+	DefaultProjector(EntityManager entityManager) {
+		this.entityManager = entityManager;
+	}
+
+	@Override
+	public AbstractJPAQuery<?, ?> apply(Class<?> domainType, AbstractJPAQuery<?, ?> query,
+			@Nullable Set<String> properties) {
+
+		if (!(properties == null || properties.isEmpty())) {
+
+			final javax.persistence.EntityGraph<?> entityGraph = entityManager.createEntityGraph(domainType);
+
+			for (String property : properties) {
+
+				final String[] split = property.split("\\.");
+				Subgraph<Object> subgraph = null;
+
+				for (int i = 0; i < split.length; i++) {
+
+					if (i < split.length - 1) {
+						subgraph = subgraph == null ? entityGraph.addSubgraph(split[i]) : subgraph.addSubgraph(split[i]);
+					} else {
+
+						if (subgraph == null) {
+							entityGraph.addAttributeNodes(split[i]);
+						} else {
+							subgraph.addAttributeNodes(split[i]);
+						}
+
+					}
+				}
+			}
+
+			query.setHint("javax.persistence.fetchgraph", entityGraph);
+		}
+
+		return query;
+	}
+}

src/main/java/org/springframework/data/jpa/repository/support/FetchableFluentQueryByPredicate.java

@@ -36,7 +36,7 @@
 import org.springframework.util.Assert;
 
 import com.querydsl.core.types.Predicate;
-import com.querydsl.jpa.JPQLQuery;
+import com.querydsl.jpa.impl.AbstractJPAQuery;
 
 /**
  * Immutable implementation of {@link FetchableFluentQuery} based on a Querydsl {@link Predicate}. All methods that
@@ -46,30 +46,32 @@
  * @param <R> Result type
  * @author Greg Turnquist
  * @author Mark Paluch
+ * @author Jens Schauder
  * @since 2.6
  */
 class FetchableFluentQueryByPredicate<S, R> extends FluentQuerySupport<R> implements FetchableFluentQuery<R> {
 
 	private final Predicate predicate;
-	private final Function<Sort, JPQLQuery<S>> finder;
-	private final BiFunction<Sort, Pageable, JPQLQuery<S>> pagedFinder;
+	private final Function<Sort, AbstractJPAQuery<?, ?>> finder;
+	private final BiFunction<Sort, Pageable, AbstractJPAQuery<?, ?>> pagedFinder;
 	private final Function<Predicate, Long> countOperation;
 	private final Function<Predicate, Boolean> existsOperation;
 	private final Class<S> entityType;
+	private final Projector projector;
 
-	public FetchableFluentQueryByPredicate(Predicate predicate, Class<R> resultType, Function<Sort, JPQLQuery<S>> finder,
-			BiFunction<Sort, Pageable, JPQLQuery<S>> pagedFinder, Function<Predicate, Long> countOperation,
-			Function<Predicate, Boolean> existsOperation, Class<S> entityType,
-			MappingContext<? extends PersistentEntity<?, ?>, ? extends PersistentProperty<?>> context) {
+	public FetchableFluentQueryByPredicate(Predicate predicate, Class<R> resultType,
+			Function<Sort, AbstractJPAQuery<?, ?>> finder, BiFunction<Sort, Pageable, AbstractJPAQuery<?, ?>> pagedFinder,
+			Function<Predicate, Long> countOperation, Function<Predicate, Boolean> existsOperation, Class<S> entityType,
+			MappingContext<? extends PersistentEntity<?, ?>, ? extends PersistentProperty<?>> context, Projector projector) {
 		this(predicate, resultType, Sort.unsorted(), null, finder, pagedFinder, countOperation, existsOperation, entityType,
-				context);
+				context, projector);
 	}
 
 	private FetchableFluentQueryByPredicate(Predicate predicate, Class<R> resultType, Sort sort,
-			@Nullable Collection<String> properties, Function<Sort, JPQLQuery<S>> finder,
-			BiFunction<Sort, Pageable, JPQLQuery<S>> pagedFinder, Function<Predicate, Long> countOperation,
+			@Nullable Collection<String> properties, Function<Sort, AbstractJPAQuery<?, ?>> finder,
+			BiFunction<Sort, Pageable, AbstractJPAQuery<?, ?>> pagedFinder, Function<Predicate, Long> countOperation,
 			Function<Predicate, Boolean> existsOperation, Class<S> entityType,
-			MappingContext<? extends PersistentEntity<?, ?>, ? extends PersistentProperty<?>> context) {
+			MappingContext<? extends PersistentEntity<?, ?>, ? extends PersistentProperty<?>> context, Projector projector) {
 
 		super(resultType, sort, properties, context);
 		this.predicate = predicate;
@@ -78,6 +80,7 @@ private FetchableFluentQueryByPredicate(Predicate predicate, Class<R> resultType
 		this.countOperation = countOperation;
 		this.existsOperation = existsOperation;
 		this.entityType = entityType;
+		this.projector = projector;
 	}
 
 	/* 
@@ -90,7 +93,8 @@ public FetchableFluentQuery<R> sortBy(Sort sort) {
 		Assert.notNull(sort, "Sort must not be null!");
 
 		return new FetchableFluentQueryByPredicate<>(this.predicate, this.resultType, this.sort.and(sort), this.properties,
-				this.finder, this.pagedFinder, this.countOperation, this.existsOperation, this.entityType, this.context);
+				this.finder, this.pagedFinder, this.countOperation, this.existsOperation, this.entityType, this.context,
+				this.projector);
 	}
 
 	/* 
@@ -106,7 +110,7 @@ public <NR> FetchableFluentQuery<NR> as(Class<NR> resultType) {
 		}
 
 		return new FetchableFluentQueryByPredicate<>(this.predicate, resultType, this.sort, this.properties, this.finder,
-				this.pagedFinder, this.countOperation, this.existsOperation, this.entityType, this.context);
+				this.pagedFinder, this.countOperation, this.existsOperation, this.entityType, this.context, this.projector);
 	}
 
 	/* 
@@ -118,7 +122,7 @@ public FetchableFluentQuery<R> project(Collection<String> properties) {
 
 		return new FetchableFluentQueryByPredicate<>(this.predicate, this.resultType, this.sort,
 				mergeProperties(properties), this.finder, this.pagedFinder, this.countOperation, this.existsOperation,
-				this.entityType, this.context);
+				this.entityType, this.context, this.projector);
 	}
 
 	/* 
@@ -128,7 +132,7 @@ public FetchableFluentQuery<R> project(Collection<String> properties) {
 	@Override
 	public R oneValue() {
 
-		List<S> results = this.finder.apply(this.sort) //
+		List<?> results = createSortedAndProjectedQuery() //
 				.limit(2) // Never need more than 2 values
 				.fetch();
 
@@ -146,7 +150,7 @@ public R oneValue() {
 	@Override
 	public R firstValue() {
 
-		List<S> results = this.finder.apply(this.sort) //
+		List<?> results = createSortedAndProjectedQuery() //
 				.limit(1) // Never need more than 1 value
 				.fetch();
 
@@ -159,9 +163,7 @@ public R firstValue() {
 	 */
 	@Override
 	public List<R> all() {
-
-		JPQLQuery<S> query = this.finder.apply(this.sort);
-		return convert(query.fetch());
+		return convert(createSortedAndProjectedQuery().fetch());
 	}
 
 	/* 
@@ -180,11 +182,17 @@ public Page<R> page(Pageable pageable) {
 	@Override
 	public Stream<R> stream() {
 
-		return this.finder.apply(this.sort) //
+		return createSortedAndProjectedQuery() //
 				.stream() //
 				.map(getConversionFunction());
 	}
 
+	private AbstractJPAQuery<?, ?> createSortedAndProjectedQuery() {
+
+		final AbstractJPAQuery<?, ?> query = this.finder.apply(this.sort);
+		return projector.apply(entityType, query, properties);
+	}
+
 	/* 
 	 * (non-Javadoc)
 	 * @see org.springframework.data.repository.query.FluentQuery.FetchableFluentQuery#count()
@@ -205,19 +213,19 @@ public boolean exists() {
 
 	private Page<R> readPage(Pageable pageable) {
 
-		JPQLQuery<S> pagedQuery = this.pagedFinder.apply(this.sort, pageable);
+		AbstractJPAQuery<?, ?> pagedQuery = this.pagedFinder.apply(this.sort, pageable);
 		List<R> paginatedResults = convert(pagedQuery.fetch());
 
 		return PageableExecutionUtils.getPage(paginatedResults, pageable, () -> this.countOperation.apply(this.predicate));
 	}
 
-	private List<R> convert(List<S> resultList) {
+	private List<R> convert(List<?> resultList) {
 
 		Function<Object, R> conversionFunction = getConversionFunction();
 		List<R> mapped = new ArrayList<>(resultList.size());
 
-		for (S s : resultList) {
-			mapped.add(conversionFunction.apply(s));
+		for (Object o : resultList) {
+			mapped.add(conversionFunction.apply(o));
 		}
 
 		return mapped;

src/main/java/org/springframework/data/jpa/repository/support/Projector.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2021 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.support;
+
+import com.querydsl.jpa.impl.AbstractJPAQuery;
+import org.springframework.lang.Nullable;
+
+import java.util.Set;
+
+/**
+ * Changes a query to produce the requested projection or something that can be mapped to it.
+ *
+ * @author Jens Schauder
+ *
+ * @since 2.6
+ */
+public interface Projector {
+
+	AbstractJPAQuery<?, ?> apply(Class<?> domainType, AbstractJPAQuery<?, ?> query, @Nullable Set<String> properties);
+}

src/main/java/org/springframework/data/jpa/repository/support/QuerydslJpaPredicateExecutor.java

@@ -69,7 +69,7 @@ public class QuerydslJpaPredicateExecutor<T> implements QuerydslPredicateExecuto
 	/**
 	 * Creates a new {@link QuerydslJpaPredicateExecutor} from the given domain class and {@link EntityManager} and uses
 	 * the given {@link EntityPathResolver} to translate the domain class into an {@link EntityPath}.
-	 *
+	 * 
 	 * @param entityInformation must not be {@literal null}.
 	 * @param entityManager must not be {@literal null}.
 	 * @param resolver must not be {@literal null}.
@@ -178,27 +178,29 @@ public <S extends T, R> R findBy(Predicate predicate, Function<FetchableFluentQu
 		Assert.notNull(predicate, "Predicate must not be null!");
 		Assert.notNull(queryFunction, "Query function must not be null!");
 
-		Function<Sort, JPQLQuery<T>> finder = sort -> {
-			JPQLQuery<T> select = createQuery(predicate).select(path);
+		Function<Sort, AbstractJPAQuery<?, ?>> finder = sort -> {
+			AbstractJPAQuery<?, ?> select = (AbstractJPAQuery<?, ?>) createQuery(predicate).select(path);
 
 			if (sort != null) {
-				select = querydsl.applySorting(sort, select);
+				select = (AbstractJPAQuery<?, ?>) querydsl.applySorting(sort, select);
 			}
 
 			return select;
 		};
 
-		BiFunction<Sort, Pageable, JPQLQuery<T>> pagedFinder = (sort, pageable) -> {
+		BiFunction<Sort, Pageable, AbstractJPAQuery<?, ?>> pagedFinder = (sort, pageable) -> {
 
-			JPQLQuery<T> select = finder.apply(sort);
+			AbstractJPAQuery<?, ?> select = finder.apply(sort);
 
 			if (pageable.isPaged()) {
-				select = querydsl.applyPagination(pageable, select);
+				select = (AbstractJPAQuery<?, ?>) querydsl.applyPagination(pageable, select);
 			}
 
 			return select;
 		};
 
+		Projector projector = new DefaultProjector(entityManager);
+
 		FetchableFluentQueryByPredicate<T, T> fluentQuery = new FetchableFluentQueryByPredicate<>( //
 				predicate, //
 				entityInformation.getJavaType(), //
@@ -207,7 +209,8 @@ public <S extends T, R> R findBy(Predicate predicate, Function<FetchableFluentQu
 				this::count, //
 				this::exists, //
 				this.entityInformation.getJavaType(), //
-				new JpaMetamodelMappingContext(Collections.singleton(this.entityManager.getMetamodel())) //
+				new JpaMetamodelMappingContext(Collections.singleton(this.entityManager.getMetamodel())), //
+				projector //
 		);
 
 		return queryFunction.apply((FetchableFluentQuery<S>) fluentQuery);
@@ -237,7 +240,7 @@ public boolean exists(Predicate predicate) {
 	 * @param predicate
 	 * @return the Querydsl {@link JPQLQuery}.
 	 */
-	protected JPQLQuery<?> createQuery(Predicate... predicate) {
+	protected AbstractJPAQuery<?, ?> createQuery(Predicate... predicate) {
 
 		Assert.notNull(predicate, "Predicate must not be null!");
 
@@ -322,4 +325,5 @@ private List<T> executeSorted(JPQLQuery<T> query, OrderSpecifier<?>... orders) {
 	private List<T> executeSorted(JPQLQuery<T> query, Sort sort) {
 		return querydsl.applySorting(sort, query).fetch();
 	}
+
 }