源代码

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