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