Polishing.

Remove method overloads accepting pure strings. Use switch-expressions.

Author: mp911de

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

@@ -15,8 +15,7 @@
  */
 package org.springframework.data.jpa.repository.query;
 
-import static org.springframework.data.jpa.repository.query.QueryTokens.TOKEN_ASC;
-import static org.springframework.data.jpa.repository.query.QueryTokens.TOKEN_DESC;
+import static org.springframework.data.jpa.repository.query.QueryTokens.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -192,7 +191,7 @@ public static Expression expression(PathAndOrigin pas) {
 	}
 
 	/**
-	 * Create a simple expression from a string as is.
+	 * Create a simple expression from a string as-is.
 	 *
 	 * @param expression
 	 * @return
@@ -204,21 +203,56 @@ public static Expression expression(String expression) {
 		return new LiteralExpression(expression);
 	}
 
-	public static Expression stringLiteral(String literal) {
+	/**
+	 * Create a simple numeric literal.
+	 *
+	 * @param literal
+	 * @return
+	 */
+	public static Expression literal(Number literal) {
+		return new LiteralExpression(literal.toString());
+	}
+
+	/**
+	 * Create a simple literal from a string by quoting it.
+	 *
+	 * @param literal
+	 * @return
+	 */
+	public static Expression literal(String literal) {
 		return new StringLiteralExpression(literal);
 	}
 
+	/**
+	 * A parameter placeholder.
+	 *
+	 * @param parameter
+	 * @return
+	 */
 	public static Expression parameter(String parameter) {
 
 		Assert.hasText(parameter, "Parameter must not be empty or null");
 
 		return new ParameterExpression(new ParameterPlaceholder(parameter));
 	}
 
+	/**
+	 * A parameter placeholder.
+	 *
+	 * @param placeholder the placeholder to use.
+	 * @return
+	 */
 	public static Expression parameter(ParameterPlaceholder placeholder) {
 		return new ParameterExpression(placeholder);
 	}
 
+	/**
+	 * Create a new ordering expression.
+	 *
+	 * @param sortExpression
+	 * @param order
+	 * @return
+	 */
 	public static Expression orderBy(Expression sortExpression, Sort.Order order) {
 		return new OrderExpression(sortExpression, order);
 	}
@@ -318,16 +352,6 @@ public Predicate notIn(Expression value) {
 				return new InPredicate(rhs, "NOT IN", value);
 			}
 
-			@Override
-			public Predicate inMultivalued(Expression value) {
-				return new MemberOfPredicate(rhs, "IN", value); // TODO: that does not line up in my head - ahahah
-			}
-
-			@Override
-			public Predicate notInMultivalued(Expression value) {
-				return new MemberOfPredicate(rhs, "NOT IN", value);
-			}
-
 			@Override
 			public Predicate memberOf(Expression value) {
 				return new MemberOfPredicate(rhs, "MEMBER OF", value);
@@ -479,30 +503,30 @@ public String toString() {
 
 	static PathAndOrigin path(Origin origin, String path) {
 
-		if(origin instanceof Entity entity) {
+		if (origin instanceof Entity entity) {
 
-            try {
+			try {
 				PropertyPath from = PropertyPath.from(path, ClassUtils.forName(entity.entity, Entity.class.getClassLoader()));
 				return new PathAndOrigin(from, entity, false);
 			} catch (ClassNotFoundException e) {
-                throw new RuntimeException(e);
-            }
-        }
-		if(origin instanceof Join join) {
+				throw new RuntimeException(e);
+			}
+		}
+		if (origin instanceof Join join) {
 
 			Origin parent = join.source;
 			List<String> segments = new ArrayList<>();
 			segments.add(join.path);
-			while(!(parent instanceof Entity)) {
-				if(parent instanceof Join pj) {
+			while (!(parent instanceof Entity)) {
+				if (parent instanceof Join pj) {
 					parent = pj.source;
 					segments.add(pj.path);
 				} else {
 					parent = null;
 				}
 			}
 
-			if(parent instanceof Entity entity) {
+			if (parent instanceof Entity entity) {
 				Collections.reverse(segments);
 				segments.add(path);
 				PathAndOrigin path1 = path(parent, StringUtils.collectionToDelimitedString(segments, "."));
@@ -561,7 +585,6 @@ record ConstructorExpression(String resultType, Multiselect multiselect) impleme
 		@Override
 		public String render(RenderContext context) {
 
-
 			return "new %s(%s)".formatted(resultType, multiselect.render(new ConstructorContext(context)));
 		}
 
@@ -591,7 +614,7 @@ public String render(RenderContext context) {
 				}
 
 				builder.append(PathExpression.render(path, context));
-				if(!context.isConstructorContext()) {
+				if (!context.isConstructorContext()) {
 					builder.append(" ").append(path.path().getSegment());
 				}
 			}
@@ -917,17 +940,6 @@ public String render(RenderContext context) {
 	 */
 	public interface WhereStep {
 
-		/**
-		 * Create a {@code BETWEEN … AND …} predicate.
-		 *
-		 * @param lower lower boundary.
-		 * @param upper upper boundary.
-		 * @return
-		 */
-		default Predicate between(String lower, String upper) {
-			return between(expression(lower), expression(upper));
-		}
-
 		/**
 		 * Create a {@code BETWEEN … AND …} predicate.
 		 *
@@ -943,142 +955,140 @@ default Predicate between(String lower, String upper) {
 		 * @param value the comparison value.
 		 * @return
 		 */
-		default Predicate gt(String value) {
-			return gt(expression(value));
-		}
+		Predicate gt(Expression value);
 
 		/**
-		 * Create a greater {@code > …} predicate.
+		 * Create a greater-or-equals {@code >= …} predicate.
 		 *
 		 * @param value the comparison value.
 		 * @return
 		 */
-		Predicate gt(Expression value);
+		Predicate gte(Expression value);
 
 		/**
-		 * Create a greater-or-equals {@code >= …} predicate.
+		 * Create a less {@code < …} predicate.
 		 *
 		 * @param value the comparison value.
 		 * @return
 		 */
-		default Predicate gte(String value) {
-			return gte(expression(value));
-		}
+		Predicate lt(Expression value);
 
 		/**
-		 * Create a greater-or-equals {@code >= …} predicate.
+		 * Create a less-or-equals {@code <= …} predicate.
 		 *
 		 * @param value the comparison value.
 		 * @return
 		 */
-		Predicate gte(Expression value);
+		Predicate lte(Expression value);
 
 		/**
-		 * Create a less {@code < …} predicate.
+		 * Create a {@code IS NULL} predicate.
 		 *
-		 * @param value the comparison value.
 		 * @return
 		 */
-		default Predicate lt(String value) {
-			return lt(expression(value));
-		}
+		Predicate isNull();
 
 		/**
-		 * Create a less {@code < …} predicate.
+		 * Create a {@code IS NOT NULL} predicate.
 		 *
-		 * @param value the comparison value.
 		 * @return
 		 */
-		Predicate lt(Expression value);
+		Predicate isNotNull();
 
 		/**
-		 * Create a less-or-equals {@code <= …} predicate.
+		 * Create a {@code IS TRUE} predicate.
 		 *
-		 * @param value the comparison value.
 		 * @return
 		 */
-		default Predicate lte(String value) {
-			return lte(expression(value));
-		}
+		Predicate isTrue();
 
 		/**
-		 * Create a less-or-equals {@code <= …} predicate.
+		 * Create a {@code IS FALSE} predicate.
 		 *
-		 * @param value the comparison value.
 		 * @return
 		 */
-		Predicate lte(Expression value);
-
-		Predicate isNull();
-
-		Predicate isNotNull();
-
-		Predicate isTrue();
-
 		Predicate isFalse();
 
+		/**
+		 * Create a {@code IS EMPTY} predicate.
+		 *
+		 * @return
+		 */
 		Predicate isEmpty();
 
+		/**
+		 * Create a {@code IS NOT EMPTY} predicate.
+		 *
+		 * @return
+		 */
 		Predicate isNotEmpty();
 
-		default Predicate in(String value) {
-			return in(expression(value));
-		}
-
+		/**
+		 * Create a {@code IN} predicate.
+		 *
+		 * @param value
+		 * @return
+		 */
 		Predicate in(Expression value);
 
-		default Predicate notIn(String value) {
-			return notIn(expression(value));
-		}
-
+		/**
+		 * Create a {@code NOT IN} predicate.
+		 *
+		 * @param value
+		 * @return
+		 */
 		Predicate notIn(Expression value);
 
-		default Predicate inMultivalued(String value) {
-			return inMultivalued(expression(value));
-		}
-
-		Predicate inMultivalued(Expression value);
-
-		default Predicate notInMultivalued(String value) {
-			return notInMultivalued(expression(value));
-		}
-
-		Predicate notInMultivalued(Expression value);
-
-		default Predicate memberOf(String value) {
-			return memberOf(expression(value));
-		}
-
+		/**
+		 * Create a {@code MEMBER OF &lt;collection&gt;} predicate.
+		 *
+		 * @param value
+		 * @return
+		 */
 		Predicate memberOf(Expression value);
 
-		default Predicate notMemberOf(String value) {
-			return notMemberOf(expression(value));
-		}
-
+		/**
+		 * Create a {@code NOT MEMBER OF &lt;collection&gt;} predicate.
+		 *
+		 * @param value
+		 * @return
+		 */
 		Predicate notMemberOf(Expression value);
 
 		default Predicate like(String value, String escape) {
 			return like(expression(value), escape);
 		}
 
+		/**
+		 * Create a {@code LIKE … ESCAPE} predicate.
+		 *
+		 * @param value
+		 * @return
+		 */
 		Predicate like(Expression value, String escape);
 
-		default Predicate notLike(String value, String escape) {
-			return notLike(expression(value), escape);
-		}
-
+		/**
+		 * Create a {@code NOT LIKE … ESCAPE} predicate.
+		 *
+		 * @param value
+		 * @return
+		 */
 		Predicate notLike(Expression value, String escape);
 
-		default Predicate eq(String value) {
-			return eq(expression(value));
-		}
-
+		/**
+		 * Create a {@code =} (equals) predicate.
+		 *
+		 * @param value
+		 * @return
+		 */
 		Predicate eq(Expression value);
 
-		default Predicate neq(String value) {
-			return neq(expression(value));
-		}
-
+		/**
+		 * Create a {@code &lt;&gt;} (not equals) predicate.
+		 *
+		 * @param value
+		 * @return
+		 */
 		Predicate neq(Expression value);
 	}
 
@@ -1243,7 +1253,7 @@ record InPredicate(Expression path, String operator, Expression predicate) imple
 		@Override
 		public String render(RenderContext context) {
 
-			//TODO: should we rather wrap it with nested or check if its a nested predicate before we call render
+			// TODO: should we rather wrap it with nested or check if its a nested predicate before we call render
 			return "%s %s (%s)".formatted(path.render(context), operator, predicate.render(context));
 		}