001/*
002 *  Copyright (c) 2022-2025, Mybatis-Flex (fuhai999@gmail.com).
003 *  <p>
004 *  Licensed under the Apache License, Version 2.0 (the "License");
005 *  you may not use this file except in compliance with the License.
006 *  You may obtain a copy of the License at
007 *  <p>
008 *  http://www.apache.org/licenses/LICENSE-2.0
009 *  <p>
010 *  Unless required by applicable law or agreed to in writing, software
011 *  distributed under the License is distributed on an "AS IS" BASIS,
012 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 *  See the License for the specific language governing permissions and
014 *  limitations under the License.
015 */
016package com.mybatisflex.core.query;
017
018import com.mybatisflex.core.constant.SqlConnector;
019import com.mybatisflex.core.util.LambdaGetter;
020import com.mybatisflex.core.util.LambdaUtil;
021
022import java.util.Collection;
023import java.util.function.BiPredicate;
024import java.util.function.BooleanSupplier;
025import java.util.function.Predicate;
026
027public class QueryConditionBuilder<Wrapper extends QueryWrapper> implements Conditional<Wrapper> {
028
029    private final Wrapper queryWrapper;
030    private final QueryColumn queryColumn;
031    private final SqlConnector connector;
032
033
034    public QueryConditionBuilder(Wrapper queryWrapper, QueryColumn queryColumn, SqlConnector connector) {
035        this.queryWrapper = queryWrapper;
036        this.queryColumn = queryColumn;
037        this.connector = connector;
038    }
039
040    private void addWhereQueryCondition(QueryCondition queryCondition) {
041        queryWrapper.addWhereQueryCondition(queryCondition, connector);
042    }
043
044    @Override
045    public Wrapper eq(Object value) {
046        addWhereQueryCondition(queryColumn.eq(value));
047        return queryWrapper;
048    }
049
050    @Override
051    public Wrapper eq(Object value, boolean isEffective) {
052        addWhereQueryCondition(queryColumn.eq(value, isEffective));
053        return queryWrapper;
054    }
055
056    @Override
057    public Wrapper eq(Object value, BooleanSupplier isEffective) {
058        addWhereQueryCondition(queryColumn.eq(value, isEffective));
059        return queryWrapper;
060    }
061
062    @Override
063    public <T> Wrapper eq(T value, Predicate<T> isEffective) {
064        addWhereQueryCondition(queryColumn.eq(value, isEffective));
065        return queryWrapper;
066    }
067
068    /**
069     * 等于 {@code =}
070     */
071    public <T> Wrapper eq(LambdaGetter<T> value) {
072        return eq(LambdaUtil.getQueryColumn(value), true);
073    }
074
075    /**
076     * 等于 {@code =}
077     */
078    public <T> Wrapper eq(LambdaGetter<T> value, boolean isEffective) {
079        return eq(LambdaUtil.getQueryColumn(value), isEffective);
080    }
081
082    /**
083     * 等于 {@code =}
084     */
085    public <T> Wrapper eq(LambdaGetter<T> value, BooleanSupplier isEffective) {
086        return eq(LambdaUtil.getQueryColumn(value), isEffective.getAsBoolean());
087    }
088
089    @Override
090    public Wrapper ne(Object value) {
091        addWhereQueryCondition(queryColumn.ne(value));
092        return queryWrapper;
093    }
094
095    @Override
096    public Wrapper ne(Object value, boolean isEffective) {
097        addWhereQueryCondition(queryColumn.ne(value, isEffective));
098        return queryWrapper;
099    }
100
101    @Override
102    public Wrapper ne(Object value, BooleanSupplier isEffective) {
103        addWhereQueryCondition(queryColumn.ne(value, isEffective));
104        return queryWrapper;
105    }
106
107    @Override
108    public <T> Wrapper ne(T value, Predicate<T> isEffective) {
109        addWhereQueryCondition(queryColumn.ne(value, isEffective));
110        return queryWrapper;
111    }
112
113    /**
114     * 不等于 {@code !=}
115     */
116    public <T> Wrapper ne(LambdaGetter<T> value) {
117        return ne(LambdaUtil.getQueryColumn(value), true);
118    }
119
120    /**
121     * 不等于 {@code !=}
122     */
123    public <T> Wrapper ne(LambdaGetter<T> value, boolean isEffective) {
124        return ne(LambdaUtil.getQueryColumn(value), isEffective);
125    }
126
127    /**
128     * 不等于 {@code !=}
129     */
130    public <T> Wrapper ne(LambdaGetter<T> value, BooleanSupplier isEffective) {
131        return ne(LambdaUtil.getQueryColumn(value), isEffective.getAsBoolean());
132    }
133
134    @Override
135    public Wrapper gt(Object value) {
136        addWhereQueryCondition(queryColumn.gt(value));
137        return queryWrapper;
138    }
139
140    @Override
141    public Wrapper gt(Object value, boolean isEffective) {
142        addWhereQueryCondition(queryColumn.gt(value, isEffective));
143        return queryWrapper;
144    }
145
146    @Override
147    public Wrapper gt(Object value, BooleanSupplier isEffective) {
148        addWhereQueryCondition(queryColumn.gt(value, isEffective));
149        return queryWrapper;
150    }
151
152    @Override
153    public <T> Wrapper gt(T value, Predicate<T> isEffective) {
154        addWhereQueryCondition(queryColumn.gt(value, isEffective));
155        return queryWrapper;
156    }
157
158    /**
159     * 大于 {@code >}
160     */
161    public <T> Wrapper gt(LambdaGetter<T> value) {
162        return gt(LambdaUtil.getQueryColumn(value), true);
163    }
164
165    /**
166     * 大于 {@code >}
167     */
168    public <T> Wrapper gt(LambdaGetter<T> value, boolean isEffective) {
169        return gt(LambdaUtil.getQueryColumn(value), isEffective);
170    }
171
172    /**
173     * 大于 {@code >}
174     */
175    public <T> Wrapper gt(LambdaGetter<T> value, BooleanSupplier isEffective) {
176        return gt(LambdaUtil.getQueryColumn(value), isEffective.getAsBoolean());
177    }
178
179    @Override
180    public Wrapper ge(Object value) {
181        addWhereQueryCondition(queryColumn.ge(value));
182        return queryWrapper;
183    }
184
185    @Override
186    public Wrapper ge(Object value, boolean isEffective) {
187        addWhereQueryCondition(queryColumn.ge(value, isEffective));
188        return queryWrapper;
189    }
190
191    @Override
192    public Wrapper ge(Object value, BooleanSupplier isEffective) {
193        addWhereQueryCondition(queryColumn.ge(value, isEffective));
194        return queryWrapper;
195    }
196
197    @Override
198    public <T> Wrapper ge(T value, Predicate<T> isEffective) {
199        addWhereQueryCondition(queryColumn.ge(value, isEffective));
200        return queryWrapper;
201    }
202
203    /**
204     * 大于等于 {@code >=}
205     */
206    public <T> Wrapper ge(LambdaGetter<T> value) {
207        return ge(LambdaUtil.getQueryColumn(value), true);
208    }
209
210    /**
211     * 大于等于 {@code >=}
212     */
213    public <T> Wrapper ge(LambdaGetter<T> value, boolean isEffective) {
214        return ge(LambdaUtil.getQueryColumn(value), isEffective);
215    }
216
217    /**
218     * 大于等于 {@code >=}
219     */
220    public <T> Wrapper ge(LambdaGetter<T> value, BooleanSupplier isEffective) {
221        return ge(LambdaUtil.getQueryColumn(value), isEffective.getAsBoolean());
222    }
223
224    @Override
225    public Wrapper lt(Object value) {
226        addWhereQueryCondition(queryColumn.lt(value));
227        return queryWrapper;
228    }
229
230    @Override
231    public Wrapper lt(Object value, boolean isEffective) {
232        addWhereQueryCondition(queryColumn.lt(value, isEffective));
233        return queryWrapper;
234    }
235
236    @Override
237    public Wrapper lt(Object value, BooleanSupplier isEffective) {
238        addWhereQueryCondition(queryColumn.lt(value, isEffective));
239        return queryWrapper;
240    }
241
242    @Override
243    public <T> Wrapper lt(T value, Predicate<T> isEffective) {
244        addWhereQueryCondition(queryColumn.lt(value, isEffective));
245        return queryWrapper;
246    }
247
248    /**
249     * 小于 {@code <}
250     */
251    public <T> Wrapper lt(LambdaGetter<T> value) {
252        return lt(LambdaUtil.getQueryColumn(value), true);
253    }
254
255    /**
256     * 小于 {@code <}
257     */
258    public <T> Wrapper lt(LambdaGetter<T> value, boolean isEffective) {
259        return lt(LambdaUtil.getQueryColumn(value), isEffective);
260    }
261
262    /**
263     * 小于 {@code <}
264     */
265    public <T> Wrapper lt(LambdaGetter<T> value, BooleanSupplier isEffective) {
266        return lt(LambdaUtil.getQueryColumn(value), isEffective.getAsBoolean());
267    }
268
269    @Override
270    public Wrapper le(Object value) {
271        addWhereQueryCondition(queryColumn.le(value));
272        return queryWrapper;
273    }
274
275    @Override
276    public Wrapper le(Object value, boolean isEffective) {
277        addWhereQueryCondition(queryColumn.le(value, isEffective));
278        return queryWrapper;
279    }
280
281    @Override
282    public Wrapper le(Object value, BooleanSupplier isEffective) {
283        addWhereQueryCondition(queryColumn.le(value, isEffective));
284        return queryWrapper;
285    }
286
287    @Override
288    public <T> Wrapper le(T value, Predicate<T> isEffective) {
289        addWhereQueryCondition(queryColumn.le(value, isEffective));
290        return queryWrapper;
291    }
292
293    /**
294     * 小于等于 {@code <=}
295     */
296    public <T> Wrapper le(LambdaGetter<T> value) {
297        return le(LambdaUtil.getQueryColumn(value), true);
298    }
299
300    /**
301     * 小于等于 {@code <=}
302     */
303    public <T> Wrapper le(LambdaGetter<T> value, boolean isEffective) {
304        return le(LambdaUtil.getQueryColumn(value), isEffective);
305    }
306
307    /**
308     * 小于等于 {@code <=}
309     */
310    public <T> Wrapper le(LambdaGetter<T> value, BooleanSupplier isEffective) {
311        return le(LambdaUtil.getQueryColumn(value), isEffective.getAsBoolean());
312    }
313
314    @Override
315    public Wrapper in(Object... value) {
316        addWhereQueryCondition(queryColumn.in(value));
317        return queryWrapper;
318    }
319
320    @Override
321    public Wrapper in(Object[] value, boolean isEffective) {
322        addWhereQueryCondition(queryColumn.in(value, isEffective));
323        return queryWrapper;
324    }
325
326    @Override
327    public Wrapper in(Object[] value, BooleanSupplier isEffective) {
328        addWhereQueryCondition(queryColumn.in(value, isEffective));
329        return queryWrapper;
330    }
331
332    @Override
333    public <T> Wrapper in(T[] value, Predicate<T[]> isEffective) {
334        addWhereQueryCondition(queryColumn.in(value, isEffective));
335        return queryWrapper;
336    }
337
338    @Override
339    public Wrapper in(Collection<?> value) {
340        addWhereQueryCondition(queryColumn.in(value));
341        return queryWrapper;
342    }
343
344    @Override
345    public Wrapper in(Collection<?> value, boolean isEffective) {
346        addWhereQueryCondition(queryColumn.in(value, isEffective));
347        return queryWrapper;
348    }
349
350    @Override
351    public Wrapper in(Collection<?> value, BooleanSupplier isEffective) {
352        addWhereQueryCondition(queryColumn.in(value, isEffective));
353        return queryWrapper;
354    }
355
356    @Override
357    public <T extends Collection<?>> Wrapper in(T value, Predicate<T> isEffective) {
358        addWhereQueryCondition(queryColumn.in(value, isEffective));
359        return queryWrapper;
360    }
361
362    @Override
363    public Wrapper in(QueryWrapper queryWrapper) {
364        addWhereQueryCondition(queryColumn.in(queryWrapper));
365        return this.queryWrapper;
366    }
367
368    @Override
369    public Wrapper in(QueryWrapper queryWrapper, boolean isEffective) {
370        addWhereQueryCondition(queryColumn.in(queryWrapper, isEffective));
371        return this.queryWrapper;
372    }
373
374    @Override
375    public Wrapper in(QueryWrapper queryWrapper, BooleanSupplier isEffective) {
376        addWhereQueryCondition(queryColumn.in(queryWrapper, isEffective));
377        return this.queryWrapper;
378    }
379
380    @Override
381    public Wrapper notIn(Object... value) {
382        addWhereQueryCondition(queryColumn.notIn(value));
383        return queryWrapper;
384    }
385
386    @Override
387    public Wrapper notIn(Object[] value, boolean isEffective) {
388        addWhereQueryCondition(queryColumn.notIn(value, isEffective));
389        return queryWrapper;
390    }
391
392    @Override
393    public Wrapper notIn(Object[] value, BooleanSupplier isEffective) {
394        addWhereQueryCondition(queryColumn.notIn(value, isEffective));
395        return queryWrapper;
396    }
397
398    @Override
399    public <T> Wrapper notIn(T[] value, Predicate<T[]> isEffective) {
400        addWhereQueryCondition(queryColumn.notIn(value, isEffective));
401        return queryWrapper;
402    }
403
404    @Override
405    public Wrapper notIn(Collection<?> value) {
406        addWhereQueryCondition(queryColumn.notIn(value));
407        return queryWrapper;
408    }
409
410    @Override
411    public Wrapper notIn(Collection<?> value, boolean isEffective) {
412        addWhereQueryCondition(queryColumn.notIn(value, isEffective));
413        return queryWrapper;
414    }
415
416    @Override
417    public Wrapper notIn(Collection<?> value, BooleanSupplier isEffective) {
418        addWhereQueryCondition(queryColumn.notIn(value, isEffective));
419        return queryWrapper;
420    }
421
422    @Override
423    public <T extends Collection<?>> Wrapper notIn(T value, Predicate<T> isEffective) {
424        addWhereQueryCondition(queryColumn.notIn(value, isEffective));
425        return queryWrapper;
426    }
427
428    @Override
429    public Wrapper notIn(QueryWrapper queryWrapper) {
430        addWhereQueryCondition(queryColumn.notIn(queryWrapper));
431        return this.queryWrapper;
432    }
433
434    @Override
435    public Wrapper notIn(QueryWrapper queryWrapper, boolean isEffective) {
436        addWhereQueryCondition(queryColumn.notIn(queryWrapper, isEffective));
437        return this.queryWrapper;
438    }
439
440    @Override
441    public Wrapper notIn(QueryWrapper queryWrapper, BooleanSupplier isEffective) {
442        addWhereQueryCondition(queryColumn.notIn(queryWrapper, isEffective));
443        return this.queryWrapper;
444    }
445
446    @Override
447    public Wrapper between(Object[] values) {
448        addWhereQueryCondition(queryColumn.between(values));
449        return queryWrapper;
450    }
451
452    @Override
453    public Wrapper between(Object[] values, boolean isEffective) {
454        addWhereQueryCondition(queryColumn.between(values, isEffective));
455        return queryWrapper;
456    }
457
458    @Override
459    public Wrapper between(Object start, Object end) {
460        addWhereQueryCondition(queryColumn.between(start, end));
461        return queryWrapper;
462    }
463
464    @Override
465    public Wrapper between(Object start, Object end, boolean isEffective) {
466        addWhereQueryCondition(queryColumn.between(start, end, isEffective));
467        return queryWrapper;
468    }
469
470    @Override
471    public Wrapper between(Object start, Object end, BooleanSupplier isEffective) {
472        addWhereQueryCondition(queryColumn.between(start, end, isEffective));
473        return queryWrapper;
474    }
475
476    @Override
477    public <S, E> Wrapper between(S start, E end, BiPredicate<S, E> isEffective) {
478        addWhereQueryCondition(queryColumn.between(start, end, isEffective));
479        return queryWrapper;
480    }
481
482    @Override
483    public Wrapper notBetween(Object[] values) {
484        addWhereQueryCondition(queryColumn.notBetween(values));
485        return queryWrapper;
486    }
487
488    @Override
489    public Wrapper notBetween(Object[] values, boolean isEffective) {
490        addWhereQueryCondition(queryColumn.notBetween(values, isEffective));
491        return queryWrapper;
492    }
493
494    @Override
495    public Wrapper notBetween(Object start, Object end) {
496        addWhereQueryCondition(queryColumn.notBetween(start, end));
497        return queryWrapper;
498    }
499
500    @Override
501    public Wrapper notBetween(Object start, Object end, boolean isEffective) {
502        addWhereQueryCondition(queryColumn.notBetween(start, end, isEffective));
503        return queryWrapper;
504    }
505
506    @Override
507    public Wrapper notBetween(Object start, Object end, BooleanSupplier isEffective) {
508        addWhereQueryCondition(queryColumn.notBetween(start, end, isEffective));
509        return queryWrapper;
510    }
511
512    @Override
513    public <S, E> Wrapper notBetween(S start, E end, BiPredicate<S, E> isEffective) {
514        addWhereQueryCondition(queryColumn.notBetween(start, end, isEffective));
515        return queryWrapper;
516    }
517
518    @Override
519    public Wrapper like(Object value) {
520        addWhereQueryCondition(queryColumn.like(value));
521        return queryWrapper;
522    }
523
524    @Override
525    public Wrapper like(Object value, boolean isEffective) {
526        addWhereQueryCondition(queryColumn.like(value, isEffective));
527        return queryWrapper;
528    }
529
530    @Override
531    public Wrapper like(Object value, BooleanSupplier isEffective) {
532        addWhereQueryCondition(queryColumn.like(value, isEffective));
533        return queryWrapper;
534    }
535
536    @Override
537    public <T> Wrapper like(T value, Predicate<T> isEffective) {
538        addWhereQueryCondition(queryColumn.like(value, isEffective));
539        return queryWrapper;
540    }
541
542    @Override
543    public Wrapper likeLeft(Object value) {
544        addWhereQueryCondition(queryColumn.likeLeft(value));
545        return queryWrapper;
546    }
547
548    @Override
549    public Wrapper likeLeft(Object value, boolean isEffective) {
550        addWhereQueryCondition(queryColumn.likeLeft(value, isEffective));
551        return queryWrapper;
552    }
553
554    @Override
555    public Wrapper likeLeft(Object value, BooleanSupplier isEffective) {
556        addWhereQueryCondition(queryColumn.likeLeft(value, isEffective));
557        return queryWrapper;
558    }
559
560    @Override
561    public <T> Wrapper likeLeft(T value, Predicate<T> isEffective) {
562        addWhereQueryCondition(queryColumn.likeLeft(value, isEffective));
563        return queryWrapper;
564    }
565
566    @Override
567    public Wrapper likeRight(Object value) {
568        addWhereQueryCondition(queryColumn.likeRight(value));
569        return queryWrapper;
570    }
571
572    @Override
573    public Wrapper likeRight(Object value, boolean isEffective) {
574        addWhereQueryCondition(queryColumn.likeRight(value, isEffective));
575        return queryWrapper;
576    }
577
578    @Override
579    public Wrapper likeRight(Object value, BooleanSupplier isEffective) {
580        addWhereQueryCondition(queryColumn.likeRight(value, isEffective));
581        return queryWrapper;
582    }
583
584    @Override
585    public <T> Wrapper likeRight(T value, Predicate<T> isEffective) {
586        addWhereQueryCondition(queryColumn.likeRight(value, isEffective));
587        return queryWrapper;
588    }
589
590    @Override
591    public Wrapper notLike(Object value) {
592        addWhereQueryCondition(queryColumn.notLike(value));
593        return queryWrapper;
594    }
595
596    @Override
597    public Wrapper notLike(Object value, boolean isEffective) {
598        addWhereQueryCondition(queryColumn.notLike(value, isEffective));
599        return queryWrapper;
600    }
601
602    @Override
603    public Wrapper notLike(Object value, BooleanSupplier isEffective) {
604        addWhereQueryCondition(queryColumn.notLike(value, isEffective));
605        return queryWrapper;
606    }
607
608    @Override
609    public <T> Wrapper notLike(T value, Predicate<T> isEffective) {
610        addWhereQueryCondition(queryColumn.notLike(value, isEffective));
611        return queryWrapper;
612    }
613
614    @Override
615    public Wrapper notLikeLeft(Object value) {
616        addWhereQueryCondition(queryColumn.notLikeLeft(value));
617        return queryWrapper;
618    }
619
620    @Override
621    public Wrapper notLikeLeft(Object value, boolean isEffective) {
622        addWhereQueryCondition(queryColumn.notLikeLeft(value, isEffective));
623        return queryWrapper;
624    }
625
626    @Override
627    public Wrapper notLikeLeft(Object value, BooleanSupplier isEffective) {
628        addWhereQueryCondition(queryColumn.notLikeLeft(value, isEffective));
629        return queryWrapper;
630    }
631
632    @Override
633    public <T> Wrapper notLikeLeft(T value, Predicate<T> isEffective) {
634        addWhereQueryCondition(queryColumn.notLikeLeft(value, isEffective));
635        return queryWrapper;
636    }
637
638    @Override
639    public Wrapper notLikeRight(Object value) {
640        addWhereQueryCondition(queryColumn.notLikeRight(value));
641        return queryWrapper;
642    }
643
644    @Override
645    public Wrapper notLikeRight(Object value, boolean isEffective) {
646        addWhereQueryCondition(queryColumn.notLikeRight(value, isEffective));
647        return queryWrapper;
648    }
649
650    @Override
651    public Wrapper notLikeRight(Object value, BooleanSupplier isEffective) {
652        addWhereQueryCondition(queryColumn.notLikeRight(value, isEffective));
653        return queryWrapper;
654    }
655
656    @Override
657    public <T> Wrapper notLikeRight(T value, Predicate<T> isEffective) {
658        addWhereQueryCondition(queryColumn.notLikeRight(value, isEffective));
659        return queryWrapper;
660    }
661
662    @Override
663    public Wrapper isNull(boolean isEffective) {
664        addWhereQueryCondition(queryColumn.isNull(isEffective));
665        return queryWrapper;
666    }
667
668    @Override
669    public Wrapper isNotNull(boolean isEffective) {
670        addWhereQueryCondition(queryColumn.isNotNull(isEffective));
671        return queryWrapper;
672    }
673
674}