Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 8969f54

Browse files
mp911demp911de
committedNov 18, 2024··
Polishing.
Remove method overloads accepting pure strings. Use switch-expressions.
1 parent f86c19c commit 8969f54

File tree

4 files changed

+198
-198
lines changed

4 files changed

+198
-198
lines changed
 

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

Lines changed: 121 additions & 111 deletions
Original file line numberDiff line numberDiff line change
@@ -15,8 +15,7 @@
1515
*/
1616
package org.springframework.data.jpa.repository.query;
1717

18-
import static org.springframework.data.jpa.repository.query.QueryTokens.TOKEN_ASC;
19-
import static org.springframework.data.jpa.repository.query.QueryTokens.TOKEN_DESC;
18+
import static org.springframework.data.jpa.repository.query.QueryTokens.*;
2019

2120
import java.util.ArrayList;
2221
import java.util.Arrays;
@@ -192,7 +191,7 @@ public static Expression expression(PathAndOrigin pas) {
192191
}
193192

194193
/**
195-
* Create a simple expression from a string as is.
194+
* Create a simple expression from a string as-is.
196195
*
197196
* @param expression
198197
* @return
@@ -204,21 +203,56 @@ public static Expression expression(String expression) {
204203
return new LiteralExpression(expression);
205204
}
206205

207-
public static Expression stringLiteral(String literal) {
206+
/**
207+
* Create a simple numeric literal.
208+
*
209+
* @param literal
210+
* @return
211+
*/
212+
public static Expression literal(Number literal) {
213+
return new LiteralExpression(literal.toString());
214+
}
215+
216+
/**
217+
* Create a simple literal from a string by quoting it.
218+
*
219+
* @param literal
220+
* @return
221+
*/
222+
public static Expression literal(String literal) {
208223
return new StringLiteralExpression(literal);
209224
}
210225

226+
/**
227+
* A parameter placeholder.
228+
*
229+
* @param parameter
230+
* @return
231+
*/
211232
public static Expression parameter(String parameter) {
212233

213234
Assert.hasText(parameter, "Parameter must not be empty or null");
214235

215236
return new ParameterExpression(new ParameterPlaceholder(parameter));
216237
}
217238

239+
/**
240+
* A parameter placeholder.
241+
*
242+
* @param placeholder the placeholder to use.
243+
* @return
244+
*/
218245
public static Expression parameter(ParameterPlaceholder placeholder) {
219246
return new ParameterExpression(placeholder);
220247
}
221248

249+
/**
250+
* Create a new ordering expression.
251+
*
252+
* @param sortExpression
253+
* @param order
254+
* @return
255+
*/
222256
public static Expression orderBy(Expression sortExpression, Sort.Order order) {
223257
return new OrderExpression(sortExpression, order);
224258
}
@@ -318,16 +352,6 @@ public Predicate notIn(Expression value) {
318352
return new InPredicate(rhs, "NOT IN", value);
319353
}
320354

321-
@Override
322-
public Predicate inMultivalued(Expression value) {
323-
return new MemberOfPredicate(rhs, "IN", value); // TODO: that does not line up in my head - ahahah
324-
}
325-
326-
@Override
327-
public Predicate notInMultivalued(Expression value) {
328-
return new MemberOfPredicate(rhs, "NOT IN", value);
329-
}
330-
331355
@Override
332356
public Predicate memberOf(Expression value) {
333357
return new MemberOfPredicate(rhs, "MEMBER OF", value);
@@ -479,30 +503,30 @@ public String toString() {
479503

480504
static PathAndOrigin path(Origin origin, String path) {
481505

482-
if(origin instanceof Entity entity) {
506+
if (origin instanceof Entity entity) {
483507

484-
try {
508+
try {
485509
PropertyPath from = PropertyPath.from(path, ClassUtils.forName(entity.entity, Entity.class.getClassLoader()));
486510
return new PathAndOrigin(from, entity, false);
487511
} catch (ClassNotFoundException e) {
488-
throw new RuntimeException(e);
489-
}
490-
}
491-
if(origin instanceof Join join) {
512+
throw new RuntimeException(e);
513+
}
514+
}
515+
if (origin instanceof Join join) {
492516

493517
Origin parent = join.source;
494518
List<String> segments = new ArrayList<>();
495519
segments.add(join.path);
496-
while(!(parent instanceof Entity)) {
497-
if(parent instanceof Join pj) {
520+
while (!(parent instanceof Entity)) {
521+
if (parent instanceof Join pj) {
498522
parent = pj.source;
499523
segments.add(pj.path);
500524
} else {
501525
parent = null;
502526
}
503527
}
504528

505-
if(parent instanceof Entity entity) {
529+
if (parent instanceof Entity entity) {
506530
Collections.reverse(segments);
507531
segments.add(path);
508532
PathAndOrigin path1 = path(parent, StringUtils.collectionToDelimitedString(segments, "."));
@@ -561,7 +585,6 @@ record ConstructorExpression(String resultType, Multiselect multiselect) impleme
561585
@Override
562586
public String render(RenderContext context) {
563587

564-
565588
return "new %s(%s)".formatted(resultType, multiselect.render(new ConstructorContext(context)));
566589
}
567590

@@ -591,7 +614,7 @@ public String render(RenderContext context) {
591614
}
592615

593616
builder.append(PathExpression.render(path, context));
594-
if(!context.isConstructorContext()) {
617+
if (!context.isConstructorContext()) {
595618
builder.append(" ").append(path.path().getSegment());
596619
}
597620
}
@@ -917,17 +940,6 @@ public String render(RenderContext context) {
917940
*/
918941
public interface WhereStep {
919942

920-
/**
921-
* Create a {@code BETWEEN … AND …} predicate.
922-
*
923-
* @param lower lower boundary.
924-
* @param upper upper boundary.
925-
* @return
926-
*/
927-
default Predicate between(String lower, String upper) {
928-
return between(expression(lower), expression(upper));
929-
}
930-
931943
/**
932944
* Create a {@code BETWEEN … AND …} predicate.
933945
*
@@ -943,142 +955,140 @@ default Predicate between(String lower, String upper) {
943955
* @param value the comparison value.
944956
* @return
945957
*/
946-
default Predicate gt(String value) {
947-
return gt(expression(value));
948-
}
958+
Predicate gt(Expression value);
949959

950960
/**
951-
* Create a greater {@code > …} predicate.
961+
* Create a greater-or-equals {@code >= …} predicate.
952962
*
953963
* @param value the comparison value.
954964
* @return
955965
*/
956-
Predicate gt(Expression value);
966+
Predicate gte(Expression value);
957967

958968
/**
959-
* Create a greater-or-equals {@code >= …} predicate.
969+
* Create a less {@code < …} predicate.
960970
*
961971
* @param value the comparison value.
962972
* @return
963973
*/
964-
default Predicate gte(String value) {
965-
return gte(expression(value));
966-
}
974+
Predicate lt(Expression value);
967975

968976
/**
969-
* Create a greater-or-equals {@code >= …} predicate.
977+
* Create a less-or-equals {@code <= …} predicate.
970978
*
971979
* @param value the comparison value.
972980
* @return
973981
*/
974-
Predicate gte(Expression value);
982+
Predicate lte(Expression value);
975983

976984
/**
977-
* Create a less {@code < …} predicate.
985+
* Create a {@code IS NULL} predicate.
978986
*
979-
* @param value the comparison value.
980987
* @return
981988
*/
982-
default Predicate lt(String value) {
983-
return lt(expression(value));
984-
}
989+
Predicate isNull();
985990

986991
/**
987-
* Create a less {@code < …} predicate.
992+
* Create a {@code IS NOT NULL} predicate.
988993
*
989-
* @param value the comparison value.
990994
* @return
991995
*/
992-
Predicate lt(Expression value);
996+
Predicate isNotNull();
993997

994998
/**
995-
* Create a less-or-equals {@code <= …} predicate.
999+
* Create a {@code IS TRUE} predicate.
9961000
*
997-
* @param value the comparison value.
9981001
* @return
9991002
*/
1000-
default Predicate lte(String value) {
1001-
return lte(expression(value));
1002-
}
1003+
Predicate isTrue();
10031004

10041005
/**
1005-
* Create a less-or-equals {@code <= …} predicate.
1006+
* Create a {@code IS FALSE} predicate.
10061007
*
1007-
* @param value the comparison value.
10081008
* @return
10091009
*/
1010-
Predicate lte(Expression value);
1011-
1012-
Predicate isNull();
1013-
1014-
Predicate isNotNull();
1015-
1016-
Predicate isTrue();
1017-
10181010
Predicate isFalse();
10191011

1012+
/**
1013+
* Create a {@code IS EMPTY} predicate.
1014+
*
1015+
* @return
1016+
*/
10201017
Predicate isEmpty();
10211018

1019+
/**
1020+
* Create a {@code IS NOT EMPTY} predicate.
1021+
*
1022+
* @return
1023+
*/
10221024
Predicate isNotEmpty();
10231025

1024-
default Predicate in(String value) {
1025-
return in(expression(value));
1026-
}
1027-
1026+
/**
1027+
* Create a {@code IN} predicate.
1028+
*
1029+
* @param value
1030+
* @return
1031+
*/
10281032
Predicate in(Expression value);
10291033

1030-
default Predicate notIn(String value) {
1031-
return notIn(expression(value));
1032-
}
1033-
1034+
/**
1035+
* Create a {@code NOT IN} predicate.
1036+
*
1037+
* @param value
1038+
* @return
1039+
*/
10341040
Predicate notIn(Expression value);
10351041

1036-
default Predicate inMultivalued(String value) {
1037-
return inMultivalued(expression(value));
1038-
}
1039-
1040-
Predicate inMultivalued(Expression value);
1041-
1042-
default Predicate notInMultivalued(String value) {
1043-
return notInMultivalued(expression(value));
1044-
}
1045-
1046-
Predicate notInMultivalued(Expression value);
1047-
1048-
default Predicate memberOf(String value) {
1049-
return memberOf(expression(value));
1050-
}
1051-
1042+
/**
1043+
* Create a {@code MEMBER OF &lt;collection&gt;} predicate.
1044+
*
1045+
* @param value
1046+
* @return
1047+
*/
10521048
Predicate memberOf(Expression value);
10531049

1054-
default Predicate notMemberOf(String value) {
1055-
return notMemberOf(expression(value));
1056-
}
1057-
1050+
/**
1051+
* Create a {@code NOT MEMBER OF &lt;collection&gt;} predicate.
1052+
*
1053+
* @param value
1054+
* @return
1055+
*/
10581056
Predicate notMemberOf(Expression value);
10591057

10601058
default Predicate like(String value, String escape) {
10611059
return like(expression(value), escape);
10621060
}
10631061

1062+
/**
1063+
* Create a {@code LIKE … ESCAPE} predicate.
1064+
*
1065+
* @param value
1066+
* @return
1067+
*/
10641068
Predicate like(Expression value, String escape);
10651069

1066-
default Predicate notLike(String value, String escape) {
1067-
return notLike(expression(value), escape);
1068-
}
1069-
1070+
/**
1071+
* Create a {@code NOT LIKE … ESCAPE} predicate.
1072+
*
1073+
* @param value
1074+
* @return
1075+
*/
10701076
Predicate notLike(Expression value, String escape);
10711077

1072-
default Predicate eq(String value) {
1073-
return eq(expression(value));
1074-
}
1075-
1078+
/**
1079+
* Create a {@code =} (equals) predicate.
1080+
*
1081+
* @param value
1082+
* @return
1083+
*/
10761084
Predicate eq(Expression value);
10771085

1078-
default Predicate neq(String value) {
1079-
return neq(expression(value));
1080-
}
1081-
1086+
/**
1087+
* Create a {@code &lt;&gt;} (not equals) predicate.
1088+
*
1089+
* @param value
1090+
* @return
1091+
*/
10821092
Predicate neq(Expression value);
10831093
}
10841094

@@ -1243,7 +1253,7 @@ record InPredicate(Expression path, String operator, Expression predicate) imple
12431253
@Override
12441254
public String render(RenderContext context) {
12451255

1246-
//TODO: should we rather wrap it with nested or check if its a nested predicate before we call render
1256+
// TODO: should we rather wrap it with nested or check if its a nested predicate before we call render
12471257
return "%s %s (%s)".formatted(path.render(context), operator, predicate.render(context));
12481258
}
12491259

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

Lines changed: 6 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -238,17 +238,12 @@ public Object prepare(@Nullable Object value) {
238238

239239
if (String.class.equals(parameterType) && !noWildcards) {
240240

241-
switch (type) {
242-
case STARTING_WITH:
243-
return String.format("%s%%", escape.escape(value.toString()));
244-
case ENDING_WITH:
245-
return String.format("%%%s", escape.escape(value.toString()));
246-
case CONTAINING:
247-
case NOT_CONTAINING:
248-
return String.format("%%%s%%", escape.escape(value.toString()));
249-
default:
250-
return value;
251-
}
241+
return switch (type) {
242+
case STARTING_WITH -> String.format("%s%%", escape.escape(value.toString()));
243+
case ENDING_WITH -> String.format("%%%s", escape.escape(value.toString()));
244+
case CONTAINING, NOT_CONTAINING -> String.format("%%%s%%", escape.escape(value.toString()));
245+
default -> value;
246+
};
252247
}
253248

254249
return Collection.class.isAssignableFrom(parameterType) //

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

Lines changed: 18 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@
1515
*/
1616
package org.springframework.data.jpa.repository.query;
1717

18-
import java.util.HashMap;
18+
import java.util.BitSet;
1919
import java.util.LinkedHashMap;
2020
import java.util.Map;
2121
import java.util.Objects;
@@ -25,11 +25,13 @@
2525
import org.springframework.util.ObjectUtils;
2626

2727
/**
28+
* Cache for PartTree queries.
29+
*
2830
* @author Christoph Strobl
2931
*/
3032
class PartTreeQueryCache {
3133

32-
private final Map<CacheKey, JpqlQueryCreator> cache = new LinkedHashMap<CacheKey, JpqlQueryCreator>() {
34+
private final Map<CacheKey, JpqlQueryCreator> cache = new LinkedHashMap<>() {
3335
@Override
3436
protected boolean removeEldestEntry(Map.Entry<CacheKey, JpqlQueryCreator> eldest) {
3537
return size() > 256;
@@ -49,30 +51,37 @@ JpqlQueryCreator put(Sort sort, JpaParametersParameterAccessor accessor, JpqlQue
4951
static class CacheKey {
5052

5153
private final Sort sort;
52-
private final Map<Integer, Nulled> params;
5354

54-
public CacheKey(Sort sort, Map<Integer, Nulled> params) {
55+
/**
56+
* Bitset of null/non-null parameter values. A 0 bit means the parameter value is {@code null}, a 1 bit means the
57+
* parameter is not {@code null}.
58+
*/
59+
private final BitSet params;
60+
61+
public CacheKey(Sort sort, BitSet params) {
5562
this.sort = sort;
5663
this.params = params;
5764
}
5865

5966
static CacheKey of(Sort sort, JpaParametersParameterAccessor accessor) {
6067

6168
Object[] values = accessor.getValues();
69+
6270
if (ObjectUtils.isEmpty(values)) {
63-
return new CacheKey(sort, Map.of());
71+
return new CacheKey(sort, new BitSet());
6472
}
6573

6674
return new CacheKey(sort, toNullableMap(values));
6775
}
6876

69-
static Map<Integer, Nulled> toNullableMap(Object[] args) {
77+
static BitSet toNullableMap(Object[] args) {
7078

71-
Map<Integer, Nulled> paramMap = new HashMap<>(args.length);
79+
BitSet bitSet = new BitSet(args.length);
7280
for (int i = 0; i < args.length; i++) {
73-
paramMap.put(i, args[i] != null ? Nulled.NO : Nulled.YES);
81+
bitSet.set(i, args[i] != null);
7482
}
75-
return paramMap;
83+
84+
return bitSet;
7685
}
7786

7887
@Override
@@ -93,8 +102,4 @@ public int hashCode() {
93102
}
94103
}
95104

96-
enum Nulled {
97-
YES, NO
98-
}
99-
100105
}

‎spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/query/JpqlQueryBuilderUnitTests.java

Lines changed: 53 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -15,8 +15,8 @@
1515
*/
1616
package org.springframework.data.jpa.repository.query;
1717

18-
import static org.assertj.core.api.Assertions.assertThat;
19-
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
18+
import static org.assertj.core.api.Assertions.*;
19+
import static org.springframework.data.jpa.repository.query.JpqlQueryBuilder.*;
2020

2121
import jakarta.persistence.Id;
2222
import jakarta.persistence.ManyToOne;
@@ -28,19 +28,6 @@
2828
import java.util.Map;
2929

3030
import org.junit.jupiter.api.Test;
31-
import org.springframework.data.domain.Sort;
32-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.AbstractJpqlQuery;
33-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.Entity;
34-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.Expression;
35-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.Join;
36-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.OrderExpression;
37-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.Origin;
38-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.ParameterPlaceholder;
39-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.PathAndOrigin;
40-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.Predicate;
41-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.RenderContext;
42-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.SelectStep;
43-
import org.springframework.data.jpa.repository.query.JpqlQueryBuilder.WhereStep;
4431

4532
/**
4633
* @author Christoph Strobl
@@ -66,11 +53,11 @@ void placeholdersErrorOnInvaludInput() {
6653
@Test
6754
void stringLiteralRendersAsQuotedString() {
6855

69-
assertThat(JpqlQueryBuilder.stringLiteral("literal").render(RenderContext.EMPTY)).isEqualTo("'literal'");
56+
assertThat(literal("literal").render(RenderContext.EMPTY)).isEqualTo("'literal'");
7057

7158
/* JPA Spec - 4.6.1 Literals:
7259
> A string literal that includes a single quote is represented by two single quotes--for example: 'literal''s'. */
73-
assertThat(JpqlQueryBuilder.stringLiteral("literal's").render(RenderContext.EMPTY)).isEqualTo("'literal''s'");
60+
assertThat(literal("literal's").render(RenderContext.EMPTY)).isEqualTo("'literal''s'");
7461
}
7562

7663
@Test
@@ -85,7 +72,7 @@ void entity() {
8572

8673
@Test
8774
void literalExpressionRendersAsIs() {
88-
Expression expression = JpqlQueryBuilder.expression("CONCAT(person.lastName, ‘, ’, person.firstName))");
75+
Expression expression = expression("CONCAT(person.lastName, ‘, ’, person.firstName))");
8976
assertThat(expression.render(RenderContext.EMPTY)).isEqualTo("CONCAT(person.lastName, ‘, ’, person.firstName))");
9077
}
9178

@@ -95,7 +82,7 @@ void xxx() {
9582
Entity entity = JpqlQueryBuilder.entity(Order.class);
9683
PathAndOrigin orderDate = JpqlQueryBuilder.path(entity, "date");
9784

98-
String fragment = JpqlQueryBuilder.where(orderDate).eq("{d '2024-11-05'}").render(ctx(entity));
85+
String fragment = JpqlQueryBuilder.where(orderDate).eq(expression("{d '2024-11-05'}")).render(ctx(entity));
9986

10087
assertThat(fragment).isEqualTo("o.date = {d '2024-11-05'}");
10188

@@ -105,37 +92,38 @@ void xxx() {
10592
@Test
10693
void predicateRendering() {
10794

108-
10995
Entity entity = JpqlQueryBuilder.entity(Order.class);
11096
WhereStep where = JpqlQueryBuilder.where(JpqlQueryBuilder.path(entity, "country"));
111-
112-
assertThat(where.between("'AT'", "'DE'").render(ctx(entity))).isEqualTo("o.country BETWEEN 'AT' AND 'DE'");
113-
assertThat(where.eq("'AT'").render(ctx(entity))).isEqualTo("o.country = 'AT'");
114-
assertThat(where.eq(JpqlQueryBuilder.stringLiteral("AT")).render(ctx(entity))).isEqualTo("o.country = 'AT'");
115-
assertThat(where.gt("'AT'").render(ctx(entity))).isEqualTo("o.country > 'AT'");
116-
assertThat(where.gte("'AT'").render(ctx(entity))).isEqualTo("o.country >= 'AT'");
97+
RenderContext context = ctx(entity);
98+
99+
assertThat(where.between(expression("'AT'"), expression("'DE'")).render(context))
100+
.isEqualTo("o.country BETWEEN 'AT' AND 'DE'");
101+
assertThat(where.eq(expression("'AT'")).render(context)).isEqualTo("o.country = 'AT'");
102+
assertThat(where.eq(literal("AT")).render(context)).isEqualTo("o.country = 'AT'");
103+
assertThat(where.gt(expression("'AT'")).render(context)).isEqualTo("o.country > 'AT'");
104+
assertThat(where.gte(expression("'AT'")).render(context)).isEqualTo("o.country >= 'AT'");
117105
// TODO: that is really really bad
118106
// lange namen
119-
assertThat(where.in("'AT', 'DE'").render(ctx(entity))).isEqualTo("o.country IN ('AT', 'DE')");
107+
assertThat(where.in(expression("'AT', 'DE'")).render(context)).isEqualTo("o.country IN ('AT', 'DE')");
120108

121109
// 1 in age - cleanup what is not used - remove everything eles
122110
// assertThat(where.inMultivalued("'AT', 'DE'").render(ctx(entity))).isEqualTo("o.country IN ('AT', 'DE')"); //
123-
assertThat(where.isEmpty().render(ctx(entity))).isEqualTo("o.country IS EMPTY");
124-
assertThat(where.isNotEmpty().render(ctx(entity))).isEqualTo("o.country IS NOT EMPTY");
125-
assertThat(where.isTrue().render(ctx(entity))).isEqualTo("o.country = TRUE");
126-
assertThat(where.isFalse().render(ctx(entity))).isEqualTo("o.country = FALSE");
127-
assertThat(where.isNull().render(ctx(entity))).isEqualTo("o.country IS NULL");
128-
assertThat(where.isNotNull().render(ctx(entity))).isEqualTo("o.country IS NOT NULL");
129-
assertThat(where.like("'\\_%'", "" + EscapeCharacter.DEFAULT.getEscapeCharacter()).render(ctx(entity)))
111+
assertThat(where.isEmpty().render(context)).isEqualTo("o.country IS EMPTY");
112+
assertThat(where.isNotEmpty().render(context)).isEqualTo("o.country IS NOT EMPTY");
113+
assertThat(where.isTrue().render(context)).isEqualTo("o.country = TRUE");
114+
assertThat(where.isFalse().render(context)).isEqualTo("o.country = FALSE");
115+
assertThat(where.isNull().render(context)).isEqualTo("o.country IS NULL");
116+
assertThat(where.isNotNull().render(context)).isEqualTo("o.country IS NOT NULL");
117+
assertThat(where.like("'\\_%'", "" + EscapeCharacter.DEFAULT.getEscapeCharacter()).render(context))
130118
.isEqualTo("o.country LIKE '\\_%' ESCAPE '\\'");
131-
assertThat(where.notLike("'\\_%'", "" + EscapeCharacter.DEFAULT.getEscapeCharacter()).render(ctx(entity)))
119+
assertThat(where.notLike(expression("'\\_%'"), "" + EscapeCharacter.DEFAULT.getEscapeCharacter()).render(context))
132120
.isEqualTo("o.country NOT LIKE '\\_%' ESCAPE '\\'");
133-
assertThat(where.lt("'AT'").render(ctx(entity))).isEqualTo("o.country < 'AT'");
134-
assertThat(where.lte("'AT'").render(ctx(entity))).isEqualTo("o.country <= 'AT'");
135-
assertThat(where.memberOf("'AT'").render(ctx(entity))).isEqualTo("'AT' MEMBER OF o.country");
121+
assertThat(where.lt(expression("'AT'")).render(context)).isEqualTo("o.country < 'AT'");
122+
assertThat(where.lte(expression("'AT'")).render(context)).isEqualTo("o.country <= 'AT'");
123+
assertThat(where.memberOf(expression("'AT'")).render(context)).isEqualTo("'AT' MEMBER OF o.country");
136124
// TODO: can we have this where.value(foo).memberOf(pathAndOrigin);
137-
assertThat(where.notMemberOf("'AT'").render(ctx(entity))).isEqualTo("'AT' NOT MEMBER OF o.country");
138-
assertThat(where.neq("'AT'").render(ctx(entity))).isEqualTo("o.country != 'AT'");
125+
assertThat(where.notMemberOf(expression("'AT'")).render(context)).isEqualTo("'AT' NOT MEMBER OF o.country");
126+
assertThat(where.neq(expression("'AT'")).render(context)).isEqualTo("o.country != 'AT'");
139127
}
140128

141129
@Test
@@ -147,23 +135,24 @@ void selectRendering() {
147135
assertThat(select.count().render()).startsWith("SELECT COUNT(o)");
148136
assertThat(select.distinct().entity().render()).startsWith("SELECT DISTINCT o ");
149137
assertThat(select.distinct().count().render()).startsWith("SELECT COUNT(DISTINCT o) ");
150-
assertThat(JpqlQueryBuilder.selectFrom(Order.class).select(JpqlQueryBuilder.path(JpqlQueryBuilder.entity(Order.class), "country")).render())
151-
.startsWith("SELECT o.country ");
152-
}
153-
154-
// @Test
155-
// void sorting() {
156-
//
157-
// JpqlQueryBuilder.orderBy(new OrderExpression() , Sort.Order.asc("country"));
158-
//
159-
// Entity entity = JpqlQueryBuilder.entity(Order.class);
160-
//
161-
// AbstractJpqlQuery query = JpqlQueryBuilder.selectFrom(Order.class)
162-
// .entity()
163-
// .orderBy()
164-
// .where(context -> "1 = 1");
165-
//
166-
// }
138+
assertThat(JpqlQueryBuilder.selectFrom(Order.class)
139+
.select(JpqlQueryBuilder.path(JpqlQueryBuilder.entity(Order.class), "country")).render())
140+
.startsWith("SELECT o.country ");
141+
}
142+
143+
// @Test
144+
// void sorting() {
145+
//
146+
// JpqlQueryBuilder.orderBy(new OrderExpression() , Sort.Order.asc("country"));
147+
//
148+
// Entity entity = JpqlQueryBuilder.entity(Order.class);
149+
//
150+
// AbstractJpqlQuery query = JpqlQueryBuilder.selectFrom(Order.class)
151+
// .entity()
152+
// .orderBy()
153+
// .where(context -> "1 = 1");
154+
//
155+
// }
167156

168157
@Test
169158
void joins() {
@@ -175,8 +164,8 @@ void joins() {
175164
PathAndOrigin productName = JpqlQueryBuilder.path(li_pr, "name");
176165
PathAndOrigin personName = JpqlQueryBuilder.path(li_pr2, "name");
177166

178-
String fragment = JpqlQueryBuilder.where(productName).eq(JpqlQueryBuilder.stringLiteral("ex30"))
179-
.and(JpqlQueryBuilder.where(personName).eq(JpqlQueryBuilder.stringLiteral("ex40"))).render(ctx(entity));
167+
String fragment = JpqlQueryBuilder.where(productName).eq(literal("ex30"))
168+
.and(JpqlQueryBuilder.where(personName).eq(literal("ex40"))).render(ctx(entity));
180169

181170
assertThat(fragment).isEqualTo("p.name = 'ex30' AND join_0.name = 'ex40'");
182171
}
@@ -191,8 +180,8 @@ void x2() {
191180
PathAndOrigin productName = JpqlQueryBuilder.path(li_pr, "name");
192181
PathAndOrigin personName = JpqlQueryBuilder.path(li_pe, "name");
193182

194-
String fragment = JpqlQueryBuilder.where(productName).eq(JpqlQueryBuilder.stringLiteral("ex30"))
195-
.and(JpqlQueryBuilder.where(personName).eq(JpqlQueryBuilder.stringLiteral("cstrobl"))).render(ctx(entity));
183+
String fragment = JpqlQueryBuilder.where(productName).eq(literal("ex30"))
184+
.and(JpqlQueryBuilder.where(personName).eq(literal("cstrobl"))).render(ctx(entity));
196185

197186
assertThat(fragment).isEqualTo("p.name = 'ex30' AND join_0.name = 'cstrobl'");
198187
}
@@ -211,13 +200,14 @@ void x3() {
211200

212201
// JpqlQueryBuilder.nested(JpqlQueryBuilder.and("x = y", "a = b")) (x = y AND a = b)
213202

214-
String fragment = JpqlQueryBuilder.where(productName).eq(JpqlQueryBuilder.stringLiteral("ex30"))
215-
.and(JpqlQueryBuilder.where(personName).eq(JpqlQueryBuilder.stringLiteral("cstrobl"))).render(ctx(entity));
203+
String fragment = JpqlQueryBuilder.where(productName).eq(literal("ex30"))
204+
.and(JpqlQueryBuilder.where(personName).eq(literal("cstrobl"))).render(ctx(entity));
216205

217206
assertThat(fragment).isEqualTo("p.name = 'ex30' AND join_0.name = 'cstrobl'");
218207
}
219208

220209
static RenderContext ctx(Entity... entities) {
210+
221211
Map<Origin, String> aliases = new LinkedHashMap<>(entities.length);
222212
for (Entity entity : entities) {
223213
aliases.put(entity, entity.alias());

0 commit comments

Comments
 (0)
Please sign in to comment.