1515 */
1616package 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
2121import jakarta .persistence .Id ;
2222import jakarta .persistence .ManyToOne ;
2828import java .util .Map ;
2929
3030import 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/**
33+ * Unit tests for {@link JpqlQueryBuilder}.
34+ *
4635 * @author Christoph Strobl
4736 */
4837class JpqlQueryBuilderUnitTests {
4938
50- @ Test
39+ @ Test // GH-3588
5140 void placeholdersRenderCorrectly () {
5241
5342 assertThat (JpqlQueryBuilder .parameter (ParameterPlaceholder .indexed (1 )).render (RenderContext .EMPTY )).isEqualTo ("?1" );
@@ -56,89 +45,88 @@ void placeholdersRenderCorrectly() {
5645 assertThat (JpqlQueryBuilder .parameter ("?1" ).render (RenderContext .EMPTY )).isEqualTo ("?1" );
5746 }
5847
59- @ Test
60- void placeholdersErrorOnInvaludInput () {
48+ @ Test // GH-3588
49+ void placeholdersErrorOnInvalidInput () {
6150 assertThatExceptionOfType (IllegalArgumentException .class )
6251 .isThrownBy (() -> JpqlQueryBuilder .parameter ((String ) null ));
6352 assertThatExceptionOfType (IllegalArgumentException .class ).isThrownBy (() -> JpqlQueryBuilder .parameter ("" ));
6453 }
6554
66- @ Test
55+ @ Test // GH-3588
6756 void stringLiteralRendersAsQuotedString () {
6857
69- assertThat (JpqlQueryBuilder . stringLiteral ("literal" ).render (RenderContext .EMPTY )).isEqualTo ("'literal'" );
58+ assertThat (literal ("literal" ).render (RenderContext .EMPTY )).isEqualTo ("'literal'" );
7059
7160 /* JPA Spec - 4.6.1 Literals:
7261 > 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'" );
62+ assertThat (literal ("literal's" ).render (RenderContext .EMPTY )).isEqualTo ("'literal''s'" );
7463 }
7564
76- @ Test
65+ @ Test // GH-3588
7766 void entity () {
7867
7968 Entity entity = JpqlQueryBuilder .entity (Order .class );
80- assertThat (entity .alias ()).isEqualTo ("o" );
81- assertThat (entity .entity ()).isEqualTo (Order .class .getName ());
82- assertThat (entity .getName ()).isEqualTo (Order .class .getSimpleName ()); // TODO: this really confusing
83- assertThat (entity .simpleName ()).isEqualTo (Order .class .getSimpleName ());
69+ assertThat (entity .getAlias ()).isEqualTo ("o" );
70+ assertThat (entity .getEntity ()).isEqualTo (Order .class .getName ());
71+ assertThat (entity .getName ()).isEqualTo (Order .class .getSimpleName ());
8472 }
8573
86- @ Test
74+ @ Test // GH-3588
8775 void literalExpressionRendersAsIs () {
88- Expression expression = JpqlQueryBuilder . expression ("CONCAT(person.lastName, ‘, ’, person.firstName))" );
76+ Expression expression = expression ("CONCAT(person.lastName, ‘, ’, person.firstName))" );
8977 assertThat (expression .render (RenderContext .EMPTY )).isEqualTo ("CONCAT(person.lastName, ‘, ’, person.firstName))" );
9078 }
9179
92- @ Test
80+ @ Test // GH-3588
9381 void xxx () {
9482
9583 Entity entity = JpqlQueryBuilder .entity (Order .class );
9684 PathAndOrigin orderDate = JpqlQueryBuilder .path (entity , "date" );
9785
98- String fragment = JpqlQueryBuilder .where (orderDate ).eq ("{d '2024-11-05'}" ).render (ctx (entity ));
86+ String fragment = JpqlQueryBuilder .where (orderDate ).eq (expression ( "{d '2024-11-05'}" ) ).render (ctx (entity ));
9987
10088 assertThat (fragment ).isEqualTo ("o.date = {d '2024-11-05'}" );
101-
102- // JpqlQueryBuilder.where(PathAndOrigin)
10389 }
10490
105- @ Test
91+ @ Test // GH-3588
10692 void predicateRendering () {
10793
108-
10994 Entity entity = JpqlQueryBuilder .entity (Order .class );
11095 WhereStep where = JpqlQueryBuilder .where (JpqlQueryBuilder .path (entity , "country" ));
96+ RenderContext context = ctx (entity );
97+
98+ assertThat (where .between (expression ("'AT'" ), expression ("'DE'" )).render (context ))
99+ .isEqualTo ("o.country BETWEEN 'AT' AND 'DE'" );
100+ assertThat (where .eq (expression ("'AT'" )).render (context )).isEqualTo ("o.country = 'AT'" );
101+ assertThat (where .eq (literal ("AT" )).render (context )).isEqualTo ("o.country = 'AT'" );
102+ assertThat (where .gt (expression ("'AT'" )).render (context )).isEqualTo ("o.country > 'AT'" );
103+ assertThat (where .gte (expression ("'AT'" )).render (context )).isEqualTo ("o.country >= 'AT'" );
111104
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'" );
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
141- @ Test
129+ @ Test // GH-3588
142130 void selectRendering () {
143131
144132 // make sure things are immutable
@@ -147,25 +135,12 @@ 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 " );
138+ assertThat (JpqlQueryBuilder .selectFrom (Order .class )
139+ .select (JpqlQueryBuilder .path (JpqlQueryBuilder .entity (Order .class ), "country" )).render ())
140+ .startsWith ("SELECT o.country " );
152141 }
153142
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- // }
167-
168- @ Test
143+ @ Test // GH-3588
169144 void joins () {
170145
171146 Entity entity = JpqlQueryBuilder .entity (LineItem .class );
@@ -175,14 +150,14 @@ void joins() {
175150 PathAndOrigin productName = JpqlQueryBuilder .path (li_pr , "name" );
176151 PathAndOrigin personName = JpqlQueryBuilder .path (li_pr2 , "name" );
177152
178- String fragment = JpqlQueryBuilder .where (productName ).eq (JpqlQueryBuilder . stringLiteral ("ex30" ))
179- .and (JpqlQueryBuilder .where (personName ).eq (JpqlQueryBuilder . stringLiteral ("ex40" ))).render (ctx (entity ));
153+ String fragment = JpqlQueryBuilder .where (productName ).eq (literal ("ex30" ))
154+ .and (JpqlQueryBuilder .where (personName ).eq (literal ("ex40" ))).render (ctx (entity ));
180155
181156 assertThat (fragment ).isEqualTo ("p.name = 'ex30' AND join_0.name = 'ex40'" );
182157 }
183158
184- @ Test
185- void x2 () {
159+ @ Test // GH-3588
160+ void joinOnPaths () {
186161
187162 Entity entity = JpqlQueryBuilder .entity (LineItem .class );
188163 Join li_pr = JpqlQueryBuilder .innerJoin (entity , "product" );
@@ -191,36 +166,17 @@ void x2() {
191166 PathAndOrigin productName = JpqlQueryBuilder .path (li_pr , "name" );
192167 PathAndOrigin personName = JpqlQueryBuilder .path (li_pe , "name" );
193168
194- String fragment = JpqlQueryBuilder .where (productName ).eq (JpqlQueryBuilder .stringLiteral ("ex30" ))
195- .and (JpqlQueryBuilder .where (personName ).eq (JpqlQueryBuilder .stringLiteral ("cstrobl" ))).render (ctx (entity ));
196-
197- assertThat (fragment ).isEqualTo ("p.name = 'ex30' AND join_0.name = 'cstrobl'" );
198- }
199-
200- @ Test
201- void x3 () {
202-
203- Entity entity = JpqlQueryBuilder .entity (LineItem .class );
204- Join li_pr = JpqlQueryBuilder .innerJoin (entity , "product" );
205- Join li_pe = JpqlQueryBuilder .innerJoin (entity , "person" );
206-
207- PathAndOrigin productName = JpqlQueryBuilder .path (li_pr , "name" );
208- PathAndOrigin personName = JpqlQueryBuilder .path (li_pe , "name" );
209-
210- // JpqlQueryBuilder.and("x = y", "a = b"); -> x = y AND a = b
211-
212- // JpqlQueryBuilder.nested(JpqlQueryBuilder.and("x = y", "a = b")) (x = y AND a = b)
213-
214- String fragment = JpqlQueryBuilder .where (productName ).eq (JpqlQueryBuilder .stringLiteral ("ex30" ))
215- .and (JpqlQueryBuilder .where (personName ).eq (JpqlQueryBuilder .stringLiteral ("cstrobl" ))).render (ctx (entity ));
169+ String fragment = JpqlQueryBuilder .where (productName ).eq (literal ("ex30" ))
170+ .and (JpqlQueryBuilder .where (personName ).eq (literal ("cstrobl" ))).render (ctx (entity ));
216171
217172 assertThat (fragment ).isEqualTo ("p.name = 'ex30' AND join_0.name = 'cstrobl'" );
218173 }
219174
220175 static RenderContext ctx (Entity ... entities ) {
176+
221177 Map <Origin , String > aliases = new LinkedHashMap <>(entities .length );
222178 for (Entity entity : entities ) {
223- aliases .put (entity , entity .alias ());
179+ aliases .put (entity , entity .getAlias ());
224180 }
225181
226182 return new RenderContext (aliases );
0 commit comments