1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package issues.gh105;
17
18 import static issues.gh105.PersonDynamicSqlSupport.*;
19 import static org.assertj.core.api.Assertions.assertThat;
20 import static org.mybatis.dynamic.sql.SqlBuilder.*;
21
22 import org.junit.jupiter.api.Test;
23 import org.mybatis.dynamic.sql.render.RenderingStrategies;
24 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
25
26 class Issue105Test {
27
28 @Test
29 void testFuzzyLikeBothPresent() {
30 String fName = "Fred";
31 String lName = "Flintstone";
32
33 SelectStatementProvider selectStatement = select(id, firstName, lastName)
34 .from(person)
35 .where(firstName, isLike(fName).map(s -> "%" + s + "%"))
36 .and(lastName, isLike(lName).map(s -> "%" + s + "%"))
37 .build()
38 .render(RenderingStrategies.MYBATIS3);
39
40 String expected = "select person_id, first_name, last_name"
41 + " from Person"
42 + " where first_name like #{parameters.p1}"
43 + " and last_name like #{parameters.p2}";
44
45 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
46 assertThat(selectStatement.getParameters()).containsEntry("p1", "%Fred%");
47 assertThat(selectStatement.getParameters()).containsEntry("p2", "%Flintstone%");
48 }
49
50 @Test
51 void testFuzzyLikeFirstNameNull() {
52 String lName = "Flintstone";
53
54 SelectStatementProvider selectStatement = select(id, firstName, lastName)
55 .from(person)
56 .where(firstName, isLikeWhenPresent((String) null).map(SearchUtils::addWildcards))
57 .and(lastName, isLike(lName).map(SearchUtils::addWildcards))
58 .build()
59 .render(RenderingStrategies.MYBATIS3);
60
61 String expected = "select person_id, first_name, last_name"
62 + " from Person"
63 + " where last_name like #{parameters.p1}";
64
65 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
66 assertThat(selectStatement.getParameters()).containsEntry("p1", "%Flintstone%");
67 }
68
69 @Test
70 void testFuzzyLikeLastNameNull() {
71 String fName = "Fred";
72
73 SelectStatementProvider selectStatement = select(id, firstName, lastName)
74 .from(person)
75 .where(firstName, isLike(fName).map(SearchUtils::addWildcards))
76 .and(lastName, isLikeWhenPresent((String) null).map(SearchUtils::addWildcards))
77 .build()
78 .render(RenderingStrategies.MYBATIS3);
79
80 String expected = "select person_id, first_name, last_name"
81 + " from Person"
82 + " where first_name like #{parameters.p1}";
83
84 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
85 assertThat(selectStatement.getParameters()).containsEntry("p1", "%Fred%");
86 }
87
88 @Test
89 void testFuzzyLikeBothNull() {
90 SelectStatementProvider selectStatement = select(id, firstName, lastName)
91 .from(person)
92 .where(firstName, isLikeWhenPresent((String) null).map(SearchUtils::addWildcards))
93 .and(lastName, isLikeWhenPresent((String) null).map(SearchUtils::addWildcards))
94 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
95 .build()
96 .render(RenderingStrategies.MYBATIS3);
97
98 String expected = "select person_id, first_name, last_name"
99 + " from Person";
100
101 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
102 assertThat(selectStatement.getParameters()).isEmpty();
103 }
104
105 @Test
106 void testBetweenTransform() {
107
108 SelectStatementProvider selectStatement = select(id, firstName, lastName)
109 .from(person)
110 .where(age, isBetween(1).and(10).map(i1 -> i1 + 1, i2 -> i2 + 2))
111 .build()
112 .render(RenderingStrategies.MYBATIS3);
113
114 String expected = "select person_id, first_name, last_name"
115 + " from Person"
116 + " where age between #{parameters.p1} and #{parameters.p2}";
117
118 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
119 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
120 assertThat(selectStatement.getParameters()).containsEntry("p2", 12);
121 }
122
123 @Test
124 void testBetweenWhenPresentTransform() {
125
126 SelectStatementProvider selectStatement = select(id, firstName, lastName)
127 .from(person)
128 .where(age, isBetweenWhenPresent(1).and(10).map(i1 -> i1 + 1, i2 -> i2 + 2))
129 .build()
130 .render(RenderingStrategies.MYBATIS3);
131
132 String expected = "select person_id, first_name, last_name"
133 + " from Person"
134 + " where age between #{parameters.p1} and #{parameters.p2}";
135
136 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
137 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
138 assertThat(selectStatement.getParameters()).containsEntry("p2", 12);
139 }
140
141 @Test
142 void testEqualTransform() {
143
144 SelectStatementProvider selectStatement = select(id, firstName, lastName)
145 .from(person)
146 .where(age, isEqualTo(1).map(i -> i + 1))
147 .build()
148 .render(RenderingStrategies.MYBATIS3);
149
150 String expected = "select person_id, first_name, last_name"
151 + " from Person"
152 + " where age = #{parameters.p1}";
153
154 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
155 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
156 }
157
158 @Test
159 void testEqualWhenPresentTransform() {
160
161 SelectStatementProvider selectStatement = select(id, firstName, lastName)
162 .from(person)
163 .where(age, isEqualToWhenPresent(1).map(i -> i + 1))
164 .build()
165 .render(RenderingStrategies.MYBATIS3);
166
167 String expected = "select person_id, first_name, last_name"
168 + " from Person"
169 + " where age = #{parameters.p1}";
170
171 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
172 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
173 }
174
175 @Test
176 void testGreaterThanTransform() {
177
178 SelectStatementProvider selectStatement = select(id, firstName, lastName)
179 .from(person)
180 .where(age, isGreaterThan(1).map(i -> i + 1))
181 .build()
182 .render(RenderingStrategies.MYBATIS3);
183
184 String expected = "select person_id, first_name, last_name"
185 + " from Person"
186 + " where age > #{parameters.p1}";
187
188 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
189 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
190 }
191
192 @Test
193 void testGreaterThanOrEqualTransform() {
194
195 SelectStatementProvider selectStatement = select(id, firstName, lastName)
196 .from(person)
197 .where(age, isGreaterThanOrEqualTo(1).map(i -> i + 1))
198 .build()
199 .render(RenderingStrategies.MYBATIS3);
200
201 String expected = "select person_id, first_name, last_name"
202 + " from Person"
203 + " where age >= #{parameters.p1}";
204
205 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
206 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
207 }
208
209 @Test
210 void testGreaterThanOrEqualWhenPresentTransform() {
211
212 SelectStatementProvider selectStatement = select(id, firstName, lastName)
213 .from(person)
214 .where(age, isGreaterThanOrEqualToWhenPresent(1).map(i -> i + 1))
215 .build()
216 .render(RenderingStrategies.MYBATIS3);
217
218 String expected = "select person_id, first_name, last_name"
219 + " from Person"
220 + " where age >= #{parameters.p1}";
221
222 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
223 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
224 }
225
226 @Test
227 void testGreaterThanWhenPresentTransform() {
228
229 SelectStatementProvider selectStatement = select(id, firstName, lastName)
230 .from(person)
231 .where(age, isGreaterThanWhenPresent(1).map(i -> i + 1))
232 .build()
233 .render(RenderingStrategies.MYBATIS3);
234
235 String expected = "select person_id, first_name, last_name"
236 + " from Person"
237 + " where age > #{parameters.p1}";
238
239 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
240 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
241 }
242
243 @Test
244 void testLessThanTransform() {
245
246 SelectStatementProvider selectStatement = select(id, firstName, lastName)
247 .from(person)
248 .where(age, isLessThan(1).map(i -> i + 1))
249 .build()
250 .render(RenderingStrategies.MYBATIS3);
251
252 String expected = "select person_id, first_name, last_name"
253 + " from Person"
254 + " where age < #{parameters.p1}";
255
256 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
257 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
258 }
259
260 @Test
261 void testLessThanOrEqualTransform() {
262
263 SelectStatementProvider selectStatement = select(id, firstName, lastName)
264 .from(person)
265 .where(age, isLessThanOrEqualTo(1).map(i -> i + 1))
266 .build()
267 .render(RenderingStrategies.MYBATIS3);
268
269 String expected = "select person_id, first_name, last_name"
270 + " from Person"
271 + " where age <= #{parameters.p1}";
272
273 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
274 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
275 }
276
277 @Test
278 void testLessThanOrEqualWhenPresentTransform() {
279
280 SelectStatementProvider selectStatement = select(id, firstName, lastName)
281 .from(person)
282 .where(age, isLessThanOrEqualToWhenPresent(1).map(i -> i + 1))
283 .build()
284 .render(RenderingStrategies.MYBATIS3);
285
286 String expected = "select person_id, first_name, last_name"
287 + " from Person"
288 + " where age <= #{parameters.p1}";
289
290 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
291 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
292 }
293
294 @Test
295 void testLessThanWhenPresentTransform() {
296
297 SelectStatementProvider selectStatement = select(id, firstName, lastName)
298 .from(person)
299 .where(age, isLessThanWhenPresent(1).map(i -> i + 1))
300 .build()
301 .render(RenderingStrategies.MYBATIS3);
302
303 String expected = "select person_id, first_name, last_name"
304 + " from Person"
305 + " where age < #{parameters.p1}";
306
307 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
308 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
309 }
310
311 @Test
312 void testLikeTransform() {
313
314 SelectStatementProvider selectStatement = select(id, firstName, lastName)
315 .from(person)
316 .where(firstName, isLike("fred").map(SearchUtils::addWildcards))
317 .build()
318 .render(RenderingStrategies.MYBATIS3);
319
320 String expected = "select person_id, first_name, last_name"
321 + " from Person"
322 + " where first_name like #{parameters.p1}";
323
324 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
325 assertThat(selectStatement.getParameters()).containsEntry("p1", "%fred%");
326 }
327
328 @Test
329 void testLikeCaseInsensitiveTransform() {
330
331 SelectStatementProvider selectStatement = select(id, firstName, lastName)
332 .from(person)
333 .where(firstName, isLikeCaseInsensitive("fred").map(SearchUtils::addWildcards))
334 .build()
335 .render(RenderingStrategies.MYBATIS3);
336
337 String expected = "select person_id, first_name, last_name"
338 + " from Person"
339 + " where upper(first_name) like #{parameters.p1}";
340
341 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
342 assertThat(selectStatement.getParameters()).containsEntry("p1", "%FRED%");
343 }
344
345 @Test
346 void testLikeCaseInsensitiveWhenPresentTransform() {
347
348 SelectStatementProvider selectStatement = select(id, firstName, lastName)
349 .from(person)
350 .where(firstName, isLikeCaseInsensitiveWhenPresent("fred").map(SearchUtils::addWildcards))
351 .build()
352 .render(RenderingStrategies.MYBATIS3);
353
354 String expected = "select person_id, first_name, last_name"
355 + " from Person"
356 + " where upper(first_name) like #{parameters.p1}";
357
358 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
359 assertThat(selectStatement.getParameters()).containsEntry("p1", "%FRED%");
360 }
361
362 @Test
363 void testLikeWhenPresentTransform() {
364
365 SelectStatementProvider selectStatement = select(id, firstName, lastName)
366 .from(person)
367 .where(firstName, isLikeWhenPresent("fred").map(SearchUtils::addWildcards))
368 .build()
369 .render(RenderingStrategies.MYBATIS3);
370
371 String expected = "select person_id, first_name, last_name"
372 + " from Person"
373 + " where first_name like #{parameters.p1}";
374
375 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
376 assertThat(selectStatement.getParameters()).containsEntry("p1", "%fred%");
377 }
378
379 @Test
380 void testNotBetweenTransform() {
381
382 SelectStatementProvider selectStatement = select(id, firstName, lastName)
383 .from(person)
384 .where(age, isNotBetween(1).and(10).map(i1 -> i1 + 1, i2 -> i2 + 2))
385 .build()
386 .render(RenderingStrategies.MYBATIS3);
387
388 String expected = "select person_id, first_name, last_name"
389 + " from Person"
390 + " where age not between #{parameters.p1} and #{parameters.p2}";
391
392 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
393 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
394 assertThat(selectStatement.getParameters()).containsEntry("p2", 12);
395 }
396
397 @Test
398 void testNotBetweenWhenPresentTransform() {
399
400 SelectStatementProvider selectStatement = select(id, firstName, lastName)
401 .from(person)
402 .where(age, isNotBetweenWhenPresent(1).and(10).map(i1 -> i1 + 1, i2 -> i2 + 2))
403 .build()
404 .render(RenderingStrategies.MYBATIS3);
405
406 String expected = "select person_id, first_name, last_name"
407 + " from Person"
408 + " where age not between #{parameters.p1} and #{parameters.p2}";
409
410 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
411 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
412 assertThat(selectStatement.getParameters()).containsEntry("p2", 12);
413 }
414
415 @Test
416 void testNotEqualTransform() {
417
418 SelectStatementProvider selectStatement = select(id, firstName, lastName)
419 .from(person)
420 .where(age, isNotEqualTo(1).map(i -> i + 1))
421 .build()
422 .render(RenderingStrategies.MYBATIS3);
423
424 String expected = "select person_id, first_name, last_name"
425 + " from Person"
426 + " where age <> #{parameters.p1}";
427
428 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
429 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
430 }
431
432 @Test
433 void testNotEqualWhenPresentTransform() {
434
435 SelectStatementProvider selectStatement = select(id, firstName, lastName)
436 .from(person)
437 .where(age, isNotEqualToWhenPresent(1).map(i -> i + 1))
438 .build()
439 .render(RenderingStrategies.MYBATIS3);
440
441 String expected = "select person_id, first_name, last_name"
442 + " from Person"
443 + " where age <> #{parameters.p1}";
444
445 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
446 assertThat(selectStatement.getParameters()).containsEntry("p1", 2);
447 }
448
449 @Test
450 void testNotLikeTransform() {
451
452 SelectStatementProvider selectStatement = select(id, firstName, lastName)
453 .from(person)
454 .where(firstName, isNotLike("fred").map(SearchUtils::addWildcards))
455 .build()
456 .render(RenderingStrategies.MYBATIS3);
457
458 String expected = "select person_id, first_name, last_name"
459 + " from Person"
460 + " where first_name not like #{parameters.p1}";
461
462 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
463 assertThat(selectStatement.getParameters()).containsEntry("p1", "%fred%");
464 }
465
466 @Test
467 void testNotLikeCaseInsensitiveTransform() {
468
469 SelectStatementProvider selectStatement = select(id, firstName, lastName)
470 .from(person)
471 .where(firstName, isNotLikeCaseInsensitive("fred").map(SearchUtils::addWildcards))
472 .build()
473 .render(RenderingStrategies.MYBATIS3);
474
475 String expected = "select person_id, first_name, last_name"
476 + " from Person"
477 + " where upper(first_name) not like #{parameters.p1}";
478
479 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
480 assertThat(selectStatement.getParameters()).containsEntry("p1", "%FRED%");
481 }
482
483 @Test
484 void testNotLikeCaseInsensitiveWhenPresentTransform() {
485
486 SelectStatementProvider selectStatement = select(id, firstName, lastName)
487 .from(person)
488 .where(firstName, isNotLikeCaseInsensitiveWhenPresent("fred").map(SearchUtils::addWildcards))
489 .build()
490 .render(RenderingStrategies.MYBATIS3);
491
492 String expected = "select person_id, first_name, last_name"
493 + " from Person"
494 + " where upper(first_name) not like #{parameters.p1}";
495
496 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
497 assertThat(selectStatement.getParameters()).containsEntry("p1", "%FRED%");
498 }
499
500 @Test
501 void testNotLikeWhenPresentTransform() {
502
503 SelectStatementProvider selectStatement = select(id, firstName, lastName)
504 .from(person)
505 .where(firstName, isNotLikeWhenPresent("fred").map(SearchUtils::addWildcards))
506 .build()
507 .render(RenderingStrategies.MYBATIS3);
508
509 String expected = "select person_id, first_name, last_name"
510 + " from Person"
511 + " where first_name not like #{parameters.p1}";
512
513 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
514 assertThat(selectStatement.getParameters()).containsEntry("p1", "%fred%");
515 }
516
517 @Test
518 void testBetweenWhenPresentTransformWithNull() {
519
520 SelectStatementProvider selectStatement = select(id, firstName, lastName)
521 .from(person)
522 .where(age, isBetweenWhenPresent(1).and((Integer) null).map(i1 -> i1 + 1, i2 -> i2 + 2))
523 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
524 .build()
525 .render(RenderingStrategies.MYBATIS3);
526
527 String expected = "select person_id, first_name, last_name"
528 + " from Person";
529
530 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
531 }
532
533 @Test
534 void testEqualWhenPresentTransformWithNull() {
535
536 SelectStatementProvider selectStatement = select(id, firstName, lastName)
537 .from(person)
538 .where(age, isEqualToWhenPresent((Integer) null).map(i -> i + 1))
539 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
540 .build()
541 .render(RenderingStrategies.MYBATIS3);
542
543 String expected = "select person_id, first_name, last_name"
544 + " from Person";
545
546 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
547 }
548
549 @Test
550 void testGreaterThanOrEqualWhenPresentTransformWithNull() {
551
552 SelectStatementProvider selectStatement = select(id, firstName, lastName)
553 .from(person)
554 .where(age, isGreaterThanOrEqualToWhenPresent((Integer) null).map(i -> i + 1))
555 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
556 .build()
557 .render(RenderingStrategies.MYBATIS3);
558
559 String expected = "select person_id, first_name, last_name"
560 + " from Person";
561
562 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
563 }
564
565 @Test
566 void testGreaterThanWhenPresentTransformWithNull() {
567
568 SelectStatementProvider selectStatement = select(id, firstName, lastName)
569 .from(person)
570 .where(age, isGreaterThanWhenPresent((Integer) null).map(i -> i + 1))
571 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
572 .build()
573 .render(RenderingStrategies.MYBATIS3);
574
575 String expected = "select person_id, first_name, last_name"
576 + " from Person";
577
578 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
579 }
580
581 @Test
582 void testLessThanOrEqualWhenPresentTransformWithNull() {
583
584 SelectStatementProvider selectStatement = select(id, firstName, lastName)
585 .from(person)
586 .where(age, isLessThanOrEqualToWhenPresent((Integer) null).map(i -> i + 1))
587 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
588 .build()
589 .render(RenderingStrategies.MYBATIS3);
590
591 String expected = "select person_id, first_name, last_name"
592 + " from Person";
593
594 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
595 }
596
597 @Test
598 void testLessThanWhenPresentTransformWithNull() {
599
600 SelectStatementProvider selectStatement = select(id, firstName, lastName)
601 .from(person)
602 .where(age, isLessThanWhenPresent((Integer) null).map(i -> i + 1))
603 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
604 .build()
605 .render(RenderingStrategies.MYBATIS3);
606
607 String expected = "select person_id, first_name, last_name"
608 + " from Person";
609
610 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
611 }
612
613 @Test
614 void testLikeCaseInsensitiveWhenPresentTransformWithNull() {
615
616 SelectStatementProvider selectStatement = select(id, firstName, lastName)
617 .from(person)
618 .where(firstName, isLikeCaseInsensitiveWhenPresent((String) null).map(SearchUtils::addWildcards))
619 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
620 .build()
621 .render(RenderingStrategies.MYBATIS3);
622
623 String expected = "select person_id, first_name, last_name"
624 + " from Person";
625
626 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
627 }
628
629 @Test
630 void testLikeWhenPresentTransformWithNull() {
631
632 SelectStatementProvider selectStatement = select(id, firstName, lastName)
633 .from(person)
634 .where(firstName, isLikeWhenPresent((String) null).map(SearchUtils::addWildcards))
635 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
636 .build()
637 .render(RenderingStrategies.MYBATIS3);
638
639 String expected = "select person_id, first_name, last_name"
640 + " from Person";
641
642 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
643 }
644
645 @Test
646 void testNotBetweenTransformWithNull() {
647
648 SelectStatementProvider selectStatement = select(id, firstName, lastName)
649 .from(person)
650 .where(age, isNotBetweenWhenPresent((Integer) null).and(10).map(i1 -> i1 + 1, i2 -> i2 + 2))
651 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
652 .build()
653 .render(RenderingStrategies.MYBATIS3);
654
655 String expected = "select person_id, first_name, last_name"
656 + " from Person";
657
658 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
659 }
660
661 @Test
662 void testNotBetweenWhenPresentTransformWithNull() {
663
664 SelectStatementProvider selectStatement = select(id, firstName, lastName)
665 .from(person)
666 .where(age, isNotBetweenWhenPresent(1).and((Integer) null).map(i1 -> i1 + 1, i2 -> i2 + 2))
667 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
668 .build()
669 .render(RenderingStrategies.MYBATIS3);
670
671 String expected = "select person_id, first_name, last_name"
672 + " from Person";
673
674 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
675 }
676
677 @Test
678 void testNotEqualWhenPresentTransformWithNull() {
679
680 SelectStatementProvider selectStatement = select(id, firstName, lastName)
681 .from(person)
682 .where(age, isNotEqualToWhenPresent((Integer) null).map(i -> i + 1))
683 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
684 .build()
685 .render(RenderingStrategies.MYBATIS3);
686
687 String expected = "select person_id, first_name, last_name"
688 + " from Person";
689
690 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
691 }
692
693 @Test
694 void testNotLikeCaseInsensitiveWhenPresentTransformWithNull() {
695
696 SelectStatementProvider selectStatement = select(id, firstName, lastName)
697 .from(person)
698 .where(firstName, isNotLikeCaseInsensitiveWhenPresent((String) null).map(SearchUtils::addWildcards))
699 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
700 .build()
701 .render(RenderingStrategies.MYBATIS3);
702
703 String expected = "select person_id, first_name, last_name"
704 + " from Person";
705
706 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
707 }
708
709 @Test
710 void testNotLikeWhenPresentTransformWithNull() {
711
712 SelectStatementProvider selectStatement = select(id, firstName, lastName)
713 .from(person)
714 .where(firstName, isNotLikeWhenPresent((String) null).map(SearchUtils::addWildcards))
715 .configureStatement(c -> c.setNonRenderingWhereClauseAllowed(true))
716 .build()
717 .render(RenderingStrategies.MYBATIS3);
718
719 String expected = "select person_id, first_name, last_name"
720 + " from Person";
721
722 assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
723 }
724 }