Hacking on Keyset queries.

Author: mp911de

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

@@ -54,7 +54,7 @@ public JpaCountQueryCreator(PartTree tree, ReturnedType returnedType, ParameterM
 	}
 
 	@Override
-	protected JpqlQueryBuilder.AbstractJpqlQuery buildQuery(Sort sort) {
+	protected JpqlQueryBuilder.Select buildQuery(Sort sort) {
 
 		JpqlQueryBuilder.SelectStep selectStep = JpqlQueryBuilder.selectFrom(returnedType.getDomainType());
 		if (this.distinct) {

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

@@ -16,10 +16,6 @@
 package org.springframework.data.jpa.repository.query;
 
 import jakarta.persistence.EntityManager;
-import jakarta.persistence.criteria.CriteriaBuilder;
-import jakarta.persistence.criteria.CriteriaQuery;
-import jakarta.persistence.criteria.Predicate;
-import jakarta.persistence.criteria.Root;
 
 import java.util.Collection;
 import java.util.LinkedHashSet;
@@ -43,6 +39,7 @@ class JpaKeysetScrollQueryCreator extends JpaQueryCreator {
 
 	private final JpaEntityInformation<?, ?> entityInformation;
 	private final KeysetScrollPosition scrollPosition;
+	private final ParameterMetadataProvider provider;
 
 	public JpaKeysetScrollQueryCreator(PartTree tree, ReturnedType type, ParameterMetadataProvider provider,
 			JpqlQueryTemplates templates, JpaEntityInformation<?, ?> entityInformation, KeysetScrollPosition scrollPosition,
@@ -52,29 +49,42 @@ public JpaKeysetScrollQueryCreator(PartTree tree, ReturnedType type, ParameterMe
 
 		this.entityInformation = entityInformation;
 		this.scrollPosition = scrollPosition;
+		this.provider = provider;
 	}
 
-	// TODO
-	protected CriteriaQuery<?> complete(@Nullable Predicate predicate, Sort sort, CriteriaQuery<?> query,
-			CriteriaBuilder builder, Root<?> root) {
+	@Override
+	protected JpqlQueryBuilder.AbstractJpqlQuery createQuery(@Nullable JpqlQueryBuilder.Predicate predicate, Sort sort) {
 
-		/*KeysetScrollSpecification<Object> keysetSpec = new KeysetScrollSpecification<>(scrollPosition, sort,
+		KeysetScrollSpecification<Object> keysetSpec = new KeysetScrollSpecification<>(scrollPosition, sort,
 				entityInformation);
-		Predicate keysetPredicate = keysetSpec.createPredicate(root, builder);
+		JpqlQueryBuilder.Predicate keysetPredicate = keysetSpec.createJpqlPredicate(getFrom(), getEntity(), value -> {
+			return JpqlQueryBuilder.expression(render(provider.synthetic(value)));
+		});
+
+		JpqlQueryBuilder.Select query = buildQuery(keysetSpec.sort());
+
+		JpqlQueryBuilder.Predicate predicateToUse = getPredicate(predicate, keysetPredicate);
+
+		if (predicateToUse != null) {
+			return query.where(predicateToUse);
+		}
+
+		return query;
+	}
 
-		CriteriaQuery<?> queryToUse = super.complete(predicate, keysetSpec.sort(), query, builder, root);
+	@Nullable
+	private static JpqlQueryBuilder.Predicate getPredicate(@Nullable JpqlQueryBuilder.Predicate predicate,
+			@Nullable JpqlQueryBuilder.Predicate keysetPredicate) {
 
 		if (keysetPredicate != null) {
-			if (queryToUse.getRestriction() != null) {
-				return queryToUse.where(builder.and(queryToUse.getRestriction(), keysetPredicate));
+			if (predicate != null) {
+				return predicate.nest().and(keysetPredicate.nest());
+			} else {
+				return keysetPredicate;
 			}
-			return queryToUse.where(keysetPredicate);
 		}
 
-		return queryToUse;*/
-
-		// TODO
-		return null;
+		return predicate;
 	}
 
 	@Override

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

@@ -21,8 +21,6 @@
 import jakarta.persistence.criteria.CriteriaQuery;
 import jakarta.persistence.criteria.Expression;
 import jakarta.persistence.criteria.From;
-import jakarta.persistence.criteria.Join;
-import jakarta.persistence.criteria.JoinType;
 import jakarta.persistence.criteria.Predicate;
 import jakarta.persistence.metamodel.Attribute;
 import jakarta.persistence.metamodel.EntityType;
@@ -31,7 +29,6 @@
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Objects;
 
 import org.springframework.data.domain.Sort;
 import org.springframework.data.jpa.domain.JpaSort;
@@ -94,6 +91,14 @@ public JpaQueryCreator(PartTree tree, ReturnedType type, ParameterMetadataProvid
 		this.entity = JpqlQueryBuilder.entity(returnedType.getDomainType());
 	}
 
+	From<?, ?> getFrom() {
+		return from;
+	}
+
+	JpqlQueryBuilder.Entity getEntity() {
+		return entity;
+	}
+
 	/**
 	 * Returns all {@link jakarta.persistence.criteria.ParameterExpression} created when creating the query.
 	 *
@@ -125,12 +130,13 @@ protected JpqlQueryBuilder.Predicate or(JpqlQueryBuilder.Predicate base, JpqlQue
 	@Override
 	protected final String complete(@Nullable JpqlQueryBuilder.Predicate predicate, Sort sort) {
 
-		JpqlQueryBuilder.AbstractJpqlQuery query = applyPredicate(predicate, buildQuery(sort));
+		JpqlQueryBuilder.AbstractJpqlQuery query = createQuery(predicate, sort);
 		return query.render();
 	}
 
-	protected JpqlQueryBuilder.AbstractJpqlQuery applyPredicate(@Nullable JpqlQueryBuilder.Predicate predicate,
-			JpqlQueryBuilder.AbstractJpqlQuery query) {
+	protected JpqlQueryBuilder.AbstractJpqlQuery createQuery(@Nullable JpqlQueryBuilder.Predicate predicate, Sort sort) {
+
+		JpqlQueryBuilder.Select query = buildQuery(sort);
 
 		if (predicate != null) {
 			return query.where(predicate);
@@ -145,7 +151,7 @@ protected JpqlQueryBuilder.AbstractJpqlQuery applyPredicate(@Nullable JpqlQueryB
 	 * @param sort
 	 * @return
 	 */
-	protected JpqlQueryBuilder.AbstractJpqlQuery buildQuery(Sort sort) {
+	protected JpqlQueryBuilder.Select buildQuery(Sort sort) {
 
 		JpqlQueryBuilder.Select select = doSelect(sort);
 
@@ -159,8 +165,8 @@ protected JpqlQueryBuilder.AbstractJpqlQuery buildQuery(Sort sort) {
 			QueryUtils.checkSortExpression(order);
 
 			try {
-				expression = JpqlQueryBuilder.expression(
-						toExpressionRecursively(entity, from, PropertyPath.from(order.getProperty(), entityType.getJavaType())));
+				expression = JpqlQueryBuilder.expression(JpqlUtils.toExpressionRecursively(entity, from,
+						PropertyPath.from(order.getProperty(), entityType.getJavaType())));
 			} catch (PropertyReferenceException e) {
 
 				if (order instanceof JpaSort.JpaOrder jpaOrder && jpaOrder.isUnsafe()) {
@@ -227,6 +233,10 @@ Collection<String> getRequiredSelection(Sort sort, ReturnedType returnedType) {
 		return returnedType.getInputProperties();
 	}
 
+	String render(ParameterMetadata<?> metadata) {
+		return "?" + (metadata.getPosition() + 1);
+	}
+
 	/**
 	 * Creates a {@link Predicate} from the given {@link Part}.
 	 *
@@ -270,7 +280,7 @@ public JpqlQueryBuilder.Predicate build() {
 			PropertyPath property = part.getProperty();
 			Type type = part.getType();
 
-			PathAndOrigin pas = toExpressionRecursively(entity, from, property);
+			PathAndOrigin pas = JpqlUtils.toExpressionRecursively(entity, from, property);
 			JpqlQueryBuilder.WhereStep where = JpqlQueryBuilder.where(pas);
 			JpqlQueryBuilder.WhereStep whereIgnoreCase = JpqlQueryBuilder.where(potentiallyIgnoreCase(pas));
 
@@ -352,19 +362,14 @@ public JpqlQueryBuilder.Predicate build() {
 			}
 		}
 
-		private String render(ParameterMetadata<?> metadata) {
-			return "?" + (metadata.getPosition() + 1);
-		}
-
 		/**
 		 * Applies an {@code UPPERCASE} conversion to the given {@link Expression} in case the underlying {@link Part}
 		 * requires ignoring case.
 		 *
 		 * @param path must not be {@literal null}.
 		 * @return
 		 */
-		private <T> JpqlQueryBuilder.Expression potentiallyIgnoreCase(JpqlQueryBuilder.Origin source,
-				PropertyPath path) {
+		private <T> JpqlQueryBuilder.Expression potentiallyIgnoreCase(JpqlQueryBuilder.Origin source, PropertyPath path) {
 			return potentiallyIgnoreCase(path, JpqlQueryBuilder.expression(source, path));
 		}
 
@@ -414,56 +419,4 @@ private boolean canUpperCase(PropertyPath path) {
 		}
 	}
 
-	static PathAndOrigin toExpressionRecursively(JpqlQueryBuilder.Origin source, From<?, ?> from,
-			PropertyPath property) {
-		return toExpressionRecursively(source, from, property, false);
-	}
-
-	static PathAndOrigin toExpressionRecursively(JpqlQueryBuilder.Origin source, From<?, ?> from,
-			PropertyPath property, boolean isForSelection) {
-		return toExpressionRecursively(source, from, property, isForSelection, false);
-	}
-
-	/**
-	 * Creates an expression with proper inner and left joins by recursively navigating the path
-	 *
-	 * @param from the {@link From}
-	 * @param property the property path
-	 * @param isForSelection is the property navigated for the selection or ordering part of the query?
-	 * @param hasRequiredOuterJoin has a parent already required an outer join?
-	 * @param <T> the type of the expression
-	 * @return the expression
-	 */
-	@SuppressWarnings("unchecked")
-	static PathAndOrigin toExpressionRecursively(JpqlQueryBuilder.Origin source, From<?, ?> from,
-			PropertyPath property, boolean isForSelection, boolean hasRequiredOuterJoin) {
-
-		String segment = property.getSegment();
-
-		boolean isLeafProperty = !property.hasNext();
-
-		boolean requiresOuterJoin = QueryUtils.requiresOuterJoin(from, property, isForSelection, hasRequiredOuterJoin);
-
-		// if it does not require an outer join and is a leaf, simply get the segment
-		if (!requiresOuterJoin && isLeafProperty) {
-			return new PathAndOrigin(property, source, false);
-		}
-
-		// get or create the join
-		JpqlQueryBuilder.Join joinSource = requiresOuterJoin ? JpqlQueryBuilder.leftJoin(source, segment)
-				: JpqlQueryBuilder.innerJoin(source, segment);
-		JoinType joinType = requiresOuterJoin ? JoinType.LEFT : JoinType.INNER;
-		Join<?, ?> join = QueryUtils.getOrCreateJoin(from, segment, joinType);
-
-		// if it's a leaf, return the join
-		if (isLeafProperty) {
-			return new PathAndOrigin(property, joinSource, true);
-		}
-
-		PropertyPath nextProperty = Objects.requireNonNull(property.next(), "An element of the property path is null");
-
-		// recurse with the next property
-		return toExpressionRecursively(joinSource, join, nextProperty, isForSelection, requiresOuterJoin);
-	}
-
 }

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

@@ -349,6 +349,40 @@ public Predicate neq(Expression value) {
 		};
 	}
 
+	@Nullable
+	public static Predicate and(List<Predicate> intermediate) {
+
+		Predicate predicate = null;
+
+		for (Predicate other : intermediate) {
+
+			if (predicate == null) {
+				predicate = other;
+			} else {
+				predicate = predicate.and(other);
+			}
+		}
+
+		return predicate;
+	}
+
+	@Nullable
+	public static Predicate or(List<Predicate> intermediate) {
+
+		Predicate predicate = null;
+
+		for (Predicate other : intermediate) {
+
+			if (predicate == null) {
+				predicate = other;
+			} else {
+				predicate = predicate.or(other);
+			}
+		}
+
+		return predicate;
+	}
+
 	/**
 	 * Fluent interface to build a {@link Select}.
 	 */

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

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2024 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 jakarta.persistence.criteria.From;
+import jakarta.persistence.criteria.Join;
+import jakarta.persistence.criteria.JoinType;
+
+import java.util.Objects;
+
+import org.springframework.data.mapping.PropertyPath;
+
+/**
+ * @author Mark Paluch
+ */
+class JpqlUtils {
+
+	static JpqlQueryBuilder.PathAndOrigin toExpressionRecursively(JpqlQueryBuilder.Origin source, From<?, ?> from,
+			PropertyPath property) {
+		return toExpressionRecursively(source, from, property, false);
+	}
+
+	static JpqlQueryBuilder.PathAndOrigin toExpressionRecursively(JpqlQueryBuilder.Origin source, From<?, ?> from,
+			PropertyPath property, boolean isForSelection) {
+		return toExpressionRecursively(source, from, property, isForSelection, false);
+	}
+
+	/**
+	 * Creates an expression with proper inner and left joins by recursively navigating the path
+	 *
+	 * @param from the {@link From}
+	 * @param property the property path
+	 * @param isForSelection is the property navigated for the selection or ordering part of the query?
+	 * @param hasRequiredOuterJoin has a parent already required an outer join?
+	 * @param <T> the type of the expression
+	 * @return the expression
+	 */
+	@SuppressWarnings("unchecked")
+	static JpqlQueryBuilder.PathAndOrigin toExpressionRecursively(JpqlQueryBuilder.Origin source, From<?, ?> from,
+			PropertyPath property, boolean isForSelection, boolean hasRequiredOuterJoin) {
+
+		String segment = property.getSegment();
+
+		boolean isLeafProperty = !property.hasNext();
+
+		boolean requiresOuterJoin = QueryUtils.requiresOuterJoin(from, property, isForSelection, hasRequiredOuterJoin);
+
+		// if it does not require an outer join and is a leaf, simply get the segment
+		if (!requiresOuterJoin && isLeafProperty) {
+			return new JpqlQueryBuilder.PathAndOrigin(property, source, false);
+		}
+
+		// get or create the join
+		JpqlQueryBuilder.Join joinSource = requiresOuterJoin ? JpqlQueryBuilder.leftJoin(source, segment)
+				: JpqlQueryBuilder.innerJoin(source, segment);
+		JoinType joinType = requiresOuterJoin ? JoinType.LEFT : JoinType.INNER;
+		Join<?, ?> join = QueryUtils.getOrCreateJoin(from, segment, joinType);
+
+		// if it's a leaf, return the join
+		if (isLeafProperty) {
+			return new JpqlQueryBuilder.PathAndOrigin(property, joinSource, true);
+		}
+
+		PropertyPath nextProperty = Objects.requireNonNull(property.next(), "An element of the property path is null");
+
+		// recurse with the next property
+		return toExpressionRecursively(joinSource, join, nextProperty, isForSelection, requiresOuterJoin);
+	}
+}