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 */
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 start AND end}
392     *
393     * @param start 开始的值
394     * @param end   结束的值
395     */
396    R between(Object start, Object end);
397
398    /**
399     * {@code BETWEEN start AND end}
400     *
401     * @param start       开始的值
402     * @param end         结束的值
403     * @param isEffective 是否有效
404     */
405    R between(Object start, Object end, boolean isEffective);
406
407    /**
408     * {@code BETWEEN start AND end}
409     *
410     * @param start       开始的值
411     * @param end         结束的值
412     * @param isEffective 是否有效
413     */
414    R between(Object start, Object end, BooleanSupplier isEffective);
415
416    /**
417     * {@code BETWEEN start AND end}
418     *
419     * @param start       开始的值
420     * @param end         结束的值
421     * @param isEffective 是否有效
422     */
423    <S, E> R between(S start, E end, BiPredicate<S, E> isEffective);
424
425    /**
426     * {@code NOT BETWEEN start AND end}
427     *
428     * @param start 开始的值
429     * @param end   结束的值
430     */
431    R notBetween(Object start, Object end);
432
433    /**
434     * {@code NOT BETWEEN start AND end}
435     *
436     * @param start       开始的值
437     * @param end         结束的值
438     * @param isEffective 是否有效
439     */
440    R notBetween(Object start, Object end, boolean isEffective);
441
442    /**
443     * {@code NOT BETWEEN start AND end}
444     *
445     * @param start       开始的值
446     * @param end         结束的值
447     * @param isEffective 是否有效
448     */
449    R notBetween(Object start, Object end, BooleanSupplier isEffective);
450
451    /**
452     * {@code NOT BETWEEN start AND end}
453     *
454     * @param start       开始的值
455     * @param end         结束的值
456     * @param isEffective 是否有效
457     */
458    <S, E> R notBetween(S start, E end, BiPredicate<S, E> isEffective);
459
460    /**
461     * {@code LIKE %value%}
462     *
463     * @param value 条件的值
464     */
465    R like(Object value);
466
467    /**
468     * {@code LIKE %value%}
469     *
470     * @param value       条件的值
471     * @param isEffective 是否有效
472     */
473    R like(Object value, boolean isEffective);
474
475    /**
476     * {@code LIKE %value%}
477     *
478     * @param value       条件的值
479     * @param isEffective 是否有效
480     */
481    R like(Object value, BooleanSupplier isEffective);
482
483    /**
484     * {@code LIKE %value%}
485     *
486     * @param value       条件的值
487     * @param isEffective 是否有效
488     */
489    <T> R like(T value, Predicate<T> isEffective);
490
491    /**
492     * {@code LIKE value%}
493     *
494     * @param value 条件的值
495     */
496    R likeLeft(Object value);
497
498    /**
499     * {@code LIKE value%}
500     *
501     * @param value       条件的值
502     * @param isEffective 是否有效
503     */
504    R likeLeft(Object value, boolean isEffective);
505
506    /**
507     * {@code LIKE value%}
508     *
509     * @param value       条件的值
510     * @param isEffective 是否有效
511     */
512    R likeLeft(Object value, BooleanSupplier isEffective);
513
514    /**
515     * {@code LIKE value%}
516     *
517     * @param value       条件的值
518     * @param isEffective 是否有效
519     */
520    <T> R likeLeft(T value, Predicate<T> isEffective);
521
522    /**
523     * {@code LIKE %value}
524     *
525     * @param value 条件的值
526     */
527    R likeRight(Object value);
528
529    /**
530     * {@code LIKE %value}
531     *
532     * @param value       条件的值
533     * @param isEffective 是否有效
534     */
535    R likeRight(Object value, boolean isEffective);
536
537    /**
538     * {@code LIKE %value}
539     *
540     * @param value       条件的值
541     * @param isEffective 是否有效
542     */
543    R likeRight(Object value, BooleanSupplier isEffective);
544
545    /**
546     * {@code LIKE %value}
547     *
548     * @param value       条件的值
549     * @param isEffective 是否有效
550     */
551    <T> R likeRight(T value, Predicate<T> isEffective);
552
553    /**
554     * {@code NOT LIKE %value%}
555     *
556     * @param value 条件的值
557     */
558    R notLike(Object value);
559
560    /**
561     * {@code NOT LIKE %value%}
562     *
563     * @param value       条件的值
564     * @param isEffective 是否有效
565     */
566    R notLike(Object value, boolean isEffective);
567
568    /**
569     * {@code NOT LIKE %value%}
570     *
571     * @param value       条件的值
572     * @param isEffective 是否有效
573     */
574    R notLike(Object value, BooleanSupplier isEffective);
575
576    /**
577     * {@code NOT LIKE %value%}
578     *
579     * @param value       条件的值
580     * @param isEffective 是否有效
581     */
582    <T> R notLike(T value, Predicate<T> isEffective);
583
584    /**
585     * {@code NOT LIKE value%}
586     *
587     * @param value 条件的值
588     */
589    R notLikeLeft(Object value);
590
591    /**
592     * {@code NOT LIKE value%}
593     *
594     * @param value       条件的值
595     * @param isEffective 是否有效
596     */
597    R notLikeLeft(Object value, boolean isEffective);
598
599    /**
600     * {@code NOT LIKE value%}
601     *
602     * @param value       条件的值
603     * @param isEffective 是否有效
604     */
605    R notLikeLeft(Object value, BooleanSupplier isEffective);
606
607    /**
608     * {@code NOT LIKE value%}
609     *
610     * @param value       条件的值
611     * @param isEffective 是否有效
612     */
613    <T> R notLikeLeft(T value, Predicate<T> isEffective);
614
615    /**
616     * {@code NOT LIKE %value}
617     *
618     * @param value 条件的值
619     */
620    R notLikeRight(Object value);
621
622    /**
623     * {@code NOT LIKE %value}
624     *
625     * @param value       条件的值
626     * @param isEffective 是否有效
627     */
628    R notLikeRight(Object value, boolean isEffective);
629
630    /**
631     * {@code NOT LIKE %value}
632     *
633     * @param value       条件的值
634     * @param isEffective 是否有效
635     */
636    R notLikeRight(Object value, BooleanSupplier isEffective);
637
638    /**
639     * {@code NOT LIKE %value}
640     *
641     * @param value       条件的值
642     * @param isEffective 是否有效
643     */
644    <T> R notLikeRight(T value, Predicate<T> isEffective);
645
646    /**
647     * {@code IS NULL}
648     */
649    default R isNull() {
650        return isNull(true);
651    }
652
653    /**
654     * {@code IS NULL}
655     *
656     * @param isEffective 是否有效
657     */
658    R isNull(boolean isEffective);
659
660    /**
661     * {@code IS NULL}
662     *
663     * @param isEffective 是否有效
664     */
665    default R isNull(BooleanSupplier isEffective) {
666        return isNull(isEffective.getAsBoolean());
667    }
668
669    /**
670     * {@code IS NOT NULL}
671     */
672    default R isNotNull() {
673        return isNotNull(true);
674    }
675
676    /**
677     * {@code IS NOT NULL}
678     *
679     * @param isEffective 是否有效
680     */
681    R isNotNull(boolean isEffective);
682
683    /**
684     * {@code IS NOT NULL}
685     *
686     * @param isEffective 是否有效
687     */
688    default R isNotNull(BooleanSupplier isEffective) {
689        return isNotNull(isEffective.getAsBoolean());
690    }
691
692}