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