源代码

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.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.Map;
024import java.util.function.BooleanSupplier;
025import java.util.function.Consumer;
026import java.util.function.Predicate;
027
028/**
029 * {@link QueryWrapper} 泛型适配器。
030 *
031 * @param <R> 返回值类型
032 * @author michael
033 * @author suomm
034 */
035@SuppressWarnings({"unchecked", "rawtypes"})
036public class QueryWrapperAdapter<R extends QueryWrapperAdapter<R>> extends QueryWrapper {
037
038    @Override
039    public WithBuilder<R> with(String name) {
040        return super.with(name);
041    }
042
043    @Override
044    public WithBuilder<R> with(String name, String... params) {
045        return super.with(name, params);
046    }
047
048    @Override
049    public WithBuilder<R> withRecursive(String name) {
050        return super.withRecursive(name);
051    }
052
053    @Override
054    public WithBuilder<R> withRecursive(String name, String... params) {
055        return super.withRecursive(name, params);
056    }
057
058    @Override
059    public R select() {
060        super.select();
061        return (R) this;
062    }
063
064    @Override
065    public R select(String... columns) {
066        super.select(columns);
067        return (R) this;
068    }
069
070    @Override
071    public <T> R select(LambdaGetter<T>... lambdaGetters) {
072        super.select(lambdaGetters);
073        return (R) this;
074    }
075
076    @Override
077    public R select(QueryColumn... queryColumns) {
078        super.select(queryColumns);
079        return (R) this;
080    }
081
082    @Override
083    public R select(Iterable<QueryColumn> queryColumns) {
084        super.select(queryColumns);
085        return (R) this;
086    }
087
088    @Override
089    public R select(QueryColumn[]... queryColumns) {
090        super.select(queryColumns);
091        return (R) this;
092    }
093
094    @Override
095    public R select(QueryColumn[] queryColumns, QueryColumn... queryColumns2) {
096        super.select(queryColumns, queryColumns2);
097        return (R) this;
098    }
099
100    public R from(Class<?>... entityClasses) {
101        super.from(entityClasses);
102        return (R) this;
103    }
104
105    @Override
106    public R from(String... tables) {
107        super.from(tables);
108        return (R) this;
109    }
110
111    @Override
112    public R from(QueryTable... tables) {
113        super.from(tables);
114        return (R) this;
115    }
116
117    @Override
118    public R from(QueryWrapper queryWrapper) {
119        super.from(queryWrapper);
120        return (R) this;
121    }
122
123    @Override
124    public R as(String alias) {
125        super.as(alias);
126        return (R) this;
127    }
128
129    @Override
130    public R where(QueryCondition queryCondition) {
131        super.where(queryCondition);
132        return (R) this;
133    }
134
135    @Override
136    public R where(String sql) {
137        super.where(sql);
138        return (R) this;
139    }
140
141    @Override
142    public R where(String sql, Object... params) {
143        super.where(sql, params);
144        return (R) this;
145    }
146
147    @Override
148    public R where(Map<String, Object> whereConditions) {
149        super.where(whereConditions);
150        return (R) this;
151    }
152
153    @Override
154    public R where(Map<String, Object> whereConditions, SqlOperators operators) {
155        super.where(whereConditions, operators);
156        return (R) this;
157    }
158
159    @Override
160    public <T> QueryConditionBuilder<R> where(LambdaGetter<T> fn) {
161        return new QueryConditionBuilder<>((R) this, LambdaUtil.getQueryColumn(fn), SqlConnector.AND);
162    }
163
164    @Override
165    public R where(Consumer<QueryWrapper> consumer) {
166        return and(consumer);
167    }
168
169    @Override
170    public R and(QueryCondition queryCondition) {
171        super.and(queryCondition);
172        return (R) this;
173    }
174
175    @Override
176    public R and(String sql) {
177        super.and(sql);
178        return (R) this;
179    }
180
181    @Override
182    public R and(String sql, Object... params) {
183        super.and(sql, params);
184        return (R) this;
185    }
186
187    @Override
188    public <T> QueryConditionBuilder<R> and(LambdaGetter<T> fn) {
189        return new QueryConditionBuilder<>((R) this, LambdaUtil.getQueryColumn(fn), SqlConnector.AND);
190    }
191
192    @Override
193    public R and(Consumer<QueryWrapper> consumer) {
194        super.and(consumer);
195        return (R) this;
196    }
197
198    @Override
199    public R and(Map<String, Object> whereConditions) {
200        super.and(whereConditions);
201        return (R) this;
202    }
203
204    @Override
205    public R and(Map<String, Object> whereConditions, SqlOperators operators) {
206        super.and(whereConditions, operators);
207        return (R) this;
208    }
209
210    @Override
211    public R and(Map<String, Object> whereConditions, SqlOperators operators, SqlConnector innerConnector) {
212        super.and(whereConditions, operators, innerConnector);
213        return (R) this;
214    }
215
216    @Override
217    public R or(QueryCondition queryCondition) {
218        super.or(queryCondition);
219        return (R) this;
220    }
221
222    @Override
223    public R or(String sql) {
224        super.or(sql);
225        return (R) this;
226    }
227
228    @Override
229    public R or(String sql, Object... params) {
230        super.or(sql, params);
231        return (R) this;
232    }
233
234    @Override
235    public <T> QueryConditionBuilder<R> or(LambdaGetter<T> fn) {
236        return new QueryConditionBuilder<>((R) this, LambdaUtil.getQueryColumn(fn), SqlConnector.OR);
237    }
238
239    @Override
240    public R or(Consumer<QueryWrapper> consumer) {
241        super.or(consumer);
242        return (R) this;
243    }
244
245    @Override
246    public R or(Map<String, Object> whereConditions) {
247        super.or(whereConditions);
248        return (R) this;
249    }
250
251    @Override
252    public R or(Map<String, Object> whereConditions, SqlOperators operators) {
253        super.or(whereConditions, operators);
254        return (R) this;
255    }
256
257    @Override
258    public R or(Map<String, Object> whereConditions, SqlOperators operators, SqlConnector innerConnector) {
259        super.or(whereConditions, operators, innerConnector);
260        return (R) this;
261    }
262
263    @Override
264    public Joiner<R> leftJoin(QueryTable table) {
265        return super.leftJoin(table);
266    }
267
268    @Override
269    public Joiner<R> leftJoin(String table) {
270        return super.leftJoin(table);
271    }
272
273    @Override
274    public Joiner<R> leftJoin(String table, boolean when) {
275        return super.leftJoin(table, when);
276    }
277
278    @Override
279    public Joiner<R> leftJoin(Class entityClass) {
280        return super.leftJoin(entityClass);
281    }
282
283    @Override
284    public Joiner<R> leftJoin(Class entityClass, boolean when) {
285        return super.leftJoin(entityClass, when);
286    }
287
288    @Override
289    public Joiner<R> leftJoin(QueryWrapper table) {
290        return super.leftJoin(table);
291    }
292
293    @Override
294    public Joiner<R> leftJoin(QueryWrapper table, boolean when) {
295        return super.leftJoin(table, when);
296    }
297
298    @Override
299    public Joiner<R> rightJoin(QueryTable table) {
300        return super.rightJoin(table);
301    }
302
303    @Override
304    public Joiner<R> rightJoin(String table) {
305        return super.rightJoin(table);
306    }
307
308    @Override
309    public Joiner<R> rightJoin(String table, boolean when) {
310        return super.rightJoin(table, when);
311    }
312
313    @Override
314    public Joiner<R> rightJoin(Class entityClass) {
315        return super.rightJoin(entityClass);
316    }
317
318    @Override
319    public Joiner<R> rightJoin(Class entityClass, boolean when) {
320        return super.rightJoin(entityClass, when);
321    }
322
323    @Override
324    public Joiner<R> rightJoin(QueryWrapper table) {
325        return super.rightJoin(table);
326    }
327
328    @Override
329    public Joiner<R> rightJoin(QueryWrapper table, boolean when) {
330        return super.rightJoin(table, when);
331    }
332
333    @Override
334    public Joiner<R> innerJoin(QueryTable table) {
335        return super.innerJoin(table);
336    }
337
338    @Override
339    public Joiner<R> innerJoin(String table) {
340        return super.innerJoin(table);
341    }
342
343    @Override
344    public Joiner<R> innerJoin(String table, boolean when) {
345        return super.innerJoin(table, when);
346    }
347
348    @Override
349    public Joiner<R> innerJoin(Class entityClass) {
350        return super.innerJoin(entityClass);
351    }
352
353    @Override
354    public Joiner<R> innerJoin(Class entityClass, boolean when) {
355        return super.innerJoin(entityClass, when);
356    }
357
358    @Override
359    public Joiner<R> innerJoin(QueryWrapper table) {
360        return super.innerJoin(table);
361    }
362
363    @Override
364    public Joiner<R> innerJoin(QueryWrapper table, boolean when) {
365        return super.innerJoin(table, when);
366    }
367
368    @Override
369    public Joiner<R> fullJoin(QueryTable table) {
370        return super.fullJoin(table);
371    }
372
373    @Override
374    public Joiner<R> fullJoin(String table) {
375        return super.fullJoin(table);
376    }
377
378    @Override
379    public Joiner<R> fullJoin(String table, boolean when) {
380        return super.fullJoin(table, when);
381    }
382
383    @Override
384    public Joiner<R> fullJoin(Class entityClass) {
385        return super.fullJoin(entityClass);
386    }
387
388    @Override
389    public Joiner<R> fullJoin(Class entityClass, boolean when) {
390        return super.fullJoin(entityClass, when);
391    }
392
393    @Override
394    public Joiner<R> fullJoin(QueryWrapper table) {
395        return super.fullJoin(table);
396    }
397
398    @Override
399    public Joiner<R> fullJoin(QueryWrapper table, boolean when) {
400        return super.fullJoin(table, when);
401    }
402
403    @Override
404    public Joiner<R> crossJoin(QueryTable table) {
405        return super.crossJoin(table);
406    }
407
408    @Override
409    public Joiner<R> crossJoin(String table) {
410        return super.crossJoin(table);
411    }
412
413    @Override
414    public Joiner<R> crossJoin(String table, boolean when) {
415        return super.crossJoin(table, when);
416    }
417
418    @Override
419    public Joiner<R> crossJoin(Class entityClass) {
420        return super.crossJoin(entityClass);
421    }
422
423    @Override
424    public Joiner<R> crossJoin(Class entityClass, boolean when) {
425        return super.crossJoin(entityClass, when);
426    }
427
428    @Override
429    public Joiner<R> crossJoin(QueryWrapper table) {
430        return super.crossJoin(table);
431    }
432
433    @Override
434    public Joiner<R> crossJoin(QueryWrapper table, boolean when) {
435        return super.crossJoin(table, when);
436    }
437
438    @Override
439    public Joiner<R> join(QueryTable table) {
440        return super.join(table);
441    }
442
443    @Override
444    public Joiner<R> join(String table) {
445        return super.join(table);
446    }
447
448    @Override
449    public Joiner<R> join(String table, boolean when) {
450        return super.join(table, when);
451    }
452
453    @Override
454    public Joiner<R> join(Class entityClass) {
455        return super.join(entityClass);
456    }
457
458    @Override
459    public Joiner<R> join(Class entityClass, boolean when) {
460        return super.join(entityClass, when);
461    }
462
463    @Override
464    public Joiner<R> join(QueryWrapper table) {
465        return super.join(table);
466    }
467
468    @Override
469    public Joiner<R> join(QueryWrapper table, boolean when) {
470        return super.join(table, when);
471    }
472
473    @Override
474    public R union(QueryWrapper unionQuery) {
475        super.union(unionQuery);
476        return (R) this;
477    }
478
479    @Override
480    public R unionAll(QueryWrapper unionQuery) {
481        super.unionAll(unionQuery);
482        return (R) this;
483    }
484
485    @Override
486    public R forUpdate() {
487        super.forUpdate();
488        return (R) this;
489    }
490
491    @Override
492    public R forUpdateNoWait() {
493        super.forUpdateNoWait();
494        return (R) this;
495    }
496
497    @Override
498    public R groupBy(String name) {
499        super.groupBy(name);
500        return (R) this;
501    }
502
503    @Override
504    public R groupBy(String... names) {
505        super.groupBy(names);
506        return (R) this;
507    }
508
509    @Override
510    public R groupBy(QueryColumn column) {
511        super.groupBy(column);
512        return (R) this;
513    }
514
515    @Override
516    public R groupBy(QueryColumn... columns) {
517        super.groupBy(columns);
518        return (R) this;
519    }
520
521    @Override
522    public <T> R groupBy(LambdaGetter<T> column) {
523        super.groupBy(column);
524        return (R) this;
525    }
526
527    @Override
528    public <T> R groupBy(LambdaGetter<T>... columns) {
529        super.groupBy(columns);
530        return (R) this;
531    }
532
533    @Override
534    public R having(QueryCondition queryCondition) {
535        super.having(queryCondition);
536        return (R) this;
537    }
538
539    @Override
540    public R orderBy(QueryColumn column, Boolean asc) {
541        super.orderBy(column, asc);
542        return (R) this;
543    }
544
545    @Override
546    public R orderBy(QueryOrderBy... orderBys) {
547        super.orderBy(orderBys);
548        return (R) this;
549    }
550
551    @Override
552    public <T> R orderBy(LambdaGetter<T> column, Boolean asc) {
553        super.orderBy(column, asc);
554        return (R) this;
555    }
556
557    @Override
558    public <T> QueryOrderByBuilder<R> orderBy(LambdaGetter<T> getter) {
559        return (QueryOrderByBuilder<R>) super.orderBy(getter);
560    }
561
562    @Override
563    public R orderBy(String column, Boolean asc) {
564        super.orderBy(column, asc);
565        return (R) this;
566    }
567
568    @Override
569    public R orderBy(String... orderBys) {
570        super.orderBy(orderBys);
571        return (R) this;
572    }
573
574    @Override
575    public R limit(Number rows) {
576        super.limit(rows);
577        return (R) this;
578    }
579
580    @Override
581    public R offset(Number offset) {
582        super.offset(offset);
583        return (R) this;
584    }
585
586    @Override
587    public R limit(Number offset, Number rows) {
588        super.limit(offset, rows);
589        return (R) this;
590    }
591
592    @Override
593    public R datasource(String datasource) {
594        super.datasource(datasource);
595        return (R) this;
596    }
597
598    @Override
599    public R hint(String hint) {
600        super.hint(hint);
601        return (R) this;
602    }
603
604
605    /////////MyBatis-Plus 兼容方法///////////////
606
607    /**
608     * 等于 {@code =}
609     *
610     * @param column 列名
611     * @param value  条件的值
612     */
613    @Override
614    public R eq(String column, Object value) {
615        and(QueryMethods.column(column).eq(value));
616        return (R) this;
617    }
618
619    /**
620     * 等于 {@code =}
621     *
622     * @param column 列名, lambda 展示
623     * @param value  值
624     */
625    @Override
626    public <T> R eq(LambdaGetter<T> column, Object value) {
627        and(QueryMethods.column(column).eq(value));
628        return (R) this;
629    }
630
631    /**
632     * 等于 {@code =}
633     *
634     * @param column      列名
635     * @param value       条件的值
636     * @param isEffective 是否有效
637     */
638    @Override
639    public R eq(String column, Object value, boolean isEffective) {
640        and(QueryMethods.column(column).eq(value).when(isEffective));
641        return (R) this;
642    }
643
644    /**
645     * 等于 {@code =}
646     *
647     * @param column      列名, lambda 展示
648     * @param value       值
649     * @param isEffective 是否有效
650     */
651    @Override
652    public <T> R eq(LambdaGetter<T> column, Object value, boolean isEffective) {
653        and(QueryMethods.column(column).eq(value).when(isEffective));
654        return (R) this;
655    }
656
657    /**
658     * 等于 {@code =}
659     *
660     * @param column      列名
661     * @param value       条件的值
662     * @param isEffective 是否有效
663     */
664    @Override
665    public <V> R eq(String column, V value, Predicate<V> isEffective) {
666        and(QueryMethods.column(column).eq(value, isEffective));
667        return (R) this;
668    }
669
670    /**
671     * 等于 {@code =}
672     *
673     * @param column      列名, lambda 展示
674     * @param value       值
675     * @param isEffective 是否有效
676     */
677    @Override
678    public <T, V> R eq(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
679        and(QueryMethods.column(column).eq(value, isEffective));
680        return (R) this;
681    }
682
683
684    /**
685     * 不等于 {@code !=}
686     *
687     * @param column 列名
688     * @param value  条件的值
689     */
690    @Override
691    public R ne(String column, Object value) {
692        and(QueryMethods.column(column).ne(value));
693        return (R) this;
694    }
695
696    /**
697     * 不等于 {@code !=}
698     *
699     * @param column 列名, lambda 展示
700     * @param value  值
701     */
702    @Override
703    public <T> R ne(LambdaGetter<T> column, Object value) {
704        and(QueryMethods.column(column).ne(value));
705        return (R) this;
706    }
707
708    /**
709     * 不等于 {@code !=}
710     *
711     * @param column      列名
712     * @param value       条件的值
713     * @param isEffective 是否有效
714     */
715    @Override
716    public R ne(String column, Object value, boolean isEffective) {
717        and(QueryMethods.column(column).ne(value).when(isEffective));
718        return (R) this;
719    }
720
721    /**
722     * 不等于 {@code !=}
723     *
724     * @param column      列名, lambda 展示
725     * @param value       值
726     * @param isEffective 是否有效
727     */
728    @Override
729    public <T> R ne(LambdaGetter<T> column, Object value, boolean isEffective) {
730        and(QueryMethods.column(column).ne(value).when(isEffective));
731        return (R) this;
732    }
733
734    /**
735     * 不等于 {@code !=}
736     *
737     * @param column      列名
738     * @param value       条件的值
739     * @param isEffective 是否有效
740     */
741    @Override
742    public <V> R ne(String column, V value, Predicate<V> isEffective) {
743        and(QueryMethods.column(column).ne(value, isEffective));
744        return (R) this;
745    }
746
747    /**
748     * 不等于 {@code !=}
749     *
750     * @param column      列名, lambda 展示
751     * @param value       值
752     * @param isEffective 是否有效
753     */
754    @Override
755    public <T, V> R ne(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
756        and(QueryMethods.column(column).ne(value, isEffective));
757        return (R) this;
758    }
759
760
761    /**
762     * 大于 {@code >}
763     *
764     * @param column 列名
765     * @param value  条件的值
766     */
767    @Override
768    public R gt(String column, Object value) {
769        and(QueryMethods.column(column).gt(value));
770        return (R) this;
771    }
772
773    /**
774     * 大于 {@code >}
775     *
776     * @param column 列名, lambda 展示
777     * @param value  值
778     */
779    @Override
780    public <T> R gt(LambdaGetter<T> column, Object value) {
781        and(QueryMethods.column(column).gt(value));
782        return (R) this;
783    }
784
785    /**
786     * 大于 {@code >}
787     *
788     * @param column      列名
789     * @param value       条件的值
790     * @param isEffective 是否有效
791     */
792    @Override
793    public R gt(String column, Object value, boolean isEffective) {
794        and(QueryMethods.column(column).gt(value).when(isEffective));
795        return (R) this;
796    }
797
798    /**
799     * 大于 {@code >}
800     *
801     * @param column      列名, lambda 展示
802     * @param value       值
803     * @param isEffective 是否有效
804     */
805    @Override
806    public <T> R gt(LambdaGetter<T> column, Object value, boolean isEffective) {
807        and(QueryMethods.column(column).gt(value).when(isEffective));
808        return (R) this;
809    }
810
811    /**
812     * 大于 {@code >}
813     *
814     * @param column      列名
815     * @param value       条件的值
816     * @param isEffective 是否有效
817     */
818    @Override
819    public <V> R gt(String column, V value, Predicate<V> isEffective) {
820        and(QueryMethods.column(column).gt(value, isEffective));
821        return (R) this;
822    }
823
824    /**
825     * 大于 {@code >}
826     *
827     * @param column      列名, lambda 展示
828     * @param value       值
829     * @param isEffective 是否有效
830     */
831    @Override
832    public <T, V> R gt(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
833        and(QueryMethods.column(column).gt(value, isEffective));
834        return (R) this;
835    }
836
837
838    /**
839     * 大于等于 {@code >=}
840     *
841     * @param column 列名
842     * @param value  条件的值
843     */
844    @Override
845    public R ge(String column, Object value) {
846        and(QueryMethods.column(column).ge(value));
847        return (R) this;
848    }
849
850    /**
851     * 大于等于 {@code >=}
852     *
853     * @param column 列名, lambda 展示
854     * @param value  值
855     */
856    @Override
857    public <T> R ge(LambdaGetter<T> column, Object value) {
858        and(QueryMethods.column(column).ge(value));
859        return (R) this;
860    }
861
862    /**
863     * 大于等于 {@code >=}
864     *
865     * @param column      列名
866     * @param value       条件的值
867     * @param isEffective 是否有效
868     */
869    @Override
870    public R ge(String column, Object value, boolean isEffective) {
871        and(QueryMethods.column(column).ge(value).when(isEffective));
872        return (R) this;
873    }
874
875    /**
876     * 大于等于 {@code >=}
877     *
878     * @param column      列名, lambda 展示
879     * @param value       值
880     * @param isEffective 是否有效
881     */
882    @Override
883    public <T> R ge(LambdaGetter<T> column, Object value, boolean isEffective) {
884        and(QueryMethods.column(column).ge(value).when(isEffective));
885        return (R) this;
886    }
887
888    /**
889     * 大于等于 {@code >=}
890     *
891     * @param column      列名
892     * @param value       条件的值
893     * @param isEffective 是否有效
894     */
895    @Override
896    public <V> R ge(String column, V value, Predicate<V> isEffective) {
897        and(QueryMethods.column(column).ge(value, isEffective));
898        return (R) this;
899    }
900
901    /**
902     * 大于等于 {@code >=}
903     *
904     * @param column      列名, lambda 展示
905     * @param value       值
906     * @param isEffective 是否有效
907     */
908    @Override
909    public <T, V> R ge(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
910        and(QueryMethods.column(column).ge(value, isEffective));
911        return (R) this;
912    }
913
914
915    /**
916     * 小于 {@code <}
917     *
918     * @param column 列名
919     * @param value  条件的值
920     */
921    @Override
922    public R lt(String column, Object value) {
923        and(QueryMethods.column(column).lt(value));
924        return (R) this;
925    }
926
927    /**
928     * 小于 {@code <}
929     *
930     * @param column 列名, lambda 展示
931     * @param value  值
932     */
933    @Override
934    public <T> R lt(LambdaGetter<T> column, Object value) {
935        and(QueryMethods.column(column).lt(value));
936        return (R) this;
937    }
938
939    /**
940     * 小于 {@code <}
941     *
942     * @param column      列名
943     * @param value       条件的值
944     * @param isEffective 是否有效
945     */
946    @Override
947    public R lt(String column, Object value, boolean isEffective) {
948        and(QueryMethods.column(column).lt(value).when(isEffective));
949        return (R) this;
950    }
951
952    /**
953     * 小于 {@code <}
954     *
955     * @param column      列名, lambda 展示
956     * @param value       值
957     * @param isEffective 是否有效
958     */
959    @Override
960    public <T> R lt(LambdaGetter<T> column, Object value, boolean isEffective) {
961        and(QueryMethods.column(column).lt(value).when(isEffective));
962        return (R) this;
963    }
964
965    /**
966     * 小于 {@code <}
967     *
968     * @param column      列名
969     * @param value       条件的值
970     * @param isEffective 是否有效
971     */
972    @Override
973    public <V> R lt(String column, V value, Predicate<V> isEffective) {
974        and(QueryMethods.column(column).lt(value, isEffective));
975        return (R) this;
976    }
977
978    /**
979     * 小于 {@code <}
980     *
981     * @param column      列名, lambda 展示
982     * @param value       值
983     * @param isEffective 是否有效
984     */
985    @Override
986    public <T, V> R lt(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
987        and(QueryMethods.column(column).lt(value, isEffective));
988        return (R) this;
989    }
990
991
992    /**
993     * 小于等于 {@code <=}
994     *
995     * @param column 列名
996     * @param value  条件的值
997     */
998    @Override
999    public R le(String column, Object value) {
1000        and(QueryMethods.column(column).le(value));
1001        return (R) this;
1002    }
1003
1004    /**
1005     * 小于等于 {@code <=}
1006     *
1007     * @param column 列名, lambda 展示
1008     * @param value  值
1009     */
1010    @Override
1011    public <T> R le(LambdaGetter<T> column, Object value) {
1012        and(QueryMethods.column(column).le(value));
1013        return (R) this;
1014    }
1015
1016    /**
1017     * 小于等于 {@code <=}
1018     *
1019     * @param column      列名
1020     * @param value       条件的值
1021     * @param isEffective 是否有效
1022     */
1023    @Override
1024    public R le(String column, Object value, boolean isEffective) {
1025        and(QueryMethods.column(column).le(value).when(isEffective));
1026        return (R) this;
1027    }
1028
1029    /**
1030     * 小于等于 {@code <=}
1031     *
1032     * @param column      列名, lambda 展示
1033     * @param value       值
1034     * @param isEffective 是否有效
1035     */
1036    @Override
1037    public <T> R le(LambdaGetter<T> column, Object value, boolean isEffective) {
1038        and(QueryMethods.column(column).le(value).when(isEffective));
1039        return (R) this;
1040    }
1041
1042    /**
1043     * 小于等于 {@code <=}
1044     *
1045     * @param column      列名
1046     * @param value       条件的值
1047     * @param isEffective 是否有效
1048     */
1049    @Override
1050    public <V> R le(String column, V value, Predicate<V> isEffective) {
1051        and(QueryMethods.column(column).le(value, isEffective));
1052        return (R) this;
1053    }
1054
1055    /**
1056     * 小于等于 {@code <=}
1057     *
1058     * @param column      列名, lambda 展示
1059     * @param value       值
1060     * @param isEffective 是否有效
1061     */
1062    @Override
1063    public <T, V> R le(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1064        and(QueryMethods.column(column).le(value, isEffective));
1065        return (R) this;
1066    }
1067
1068
1069    /**
1070     * {@code IN(value)}
1071     *
1072     * @param column 列名
1073     * @param values 条件的值
1074     */
1075    @Override
1076    public R in(String column, Object... values) {
1077        and(QueryMethods.column(column).in(values));
1078        return (R) this;
1079    }
1080
1081    /**
1082     * {@code IN(value)}
1083     *
1084     * @param column 列名, lambda 展示
1085     * @param values 值
1086     */
1087    @Override
1088    public <T> R in(LambdaGetter<T> column, Object... values) {
1089        and(QueryMethods.column(column).in(values));
1090        return (R) this;
1091    }
1092
1093
1094    /**
1095     * {@code IN(value)}
1096     *
1097     * @param column       列名
1098     * @param queryWrapper 条件的值
1099     */
1100    @Override
1101    public R in(String column, QueryWrapper queryWrapper) {
1102        and(QueryMethods.column(column).in(queryWrapper));
1103        return (R) this;
1104    }
1105
1106
1107    /**
1108     * {@code IN(value)}
1109     *
1110     * @param column       列名, lambda 展示
1111     * @param queryWrapper 值
1112     */
1113    @Override
1114    public <T> R in(LambdaGetter<T> column, QueryWrapper queryWrapper) {
1115        and(QueryMethods.column(column).in(queryWrapper));
1116        return (R) this;
1117    }
1118
1119
1120    /**
1121     * {@code IN(value)}
1122     *
1123     * @param column 列名
1124     * @param values 条件的值
1125     */
1126    @Override
1127    public R in(String column, Collection<?> values) {
1128        and(QueryMethods.column(column).in(values));
1129        return (R) this;
1130    }
1131
1132    /**
1133     * {@code IN(value)}
1134     *
1135     * @param column 列名, lambda 展示
1136     * @param values 值
1137     */
1138    @Override
1139    public <T> R in(LambdaGetter<T> column, Collection<?> values) {
1140        and(QueryMethods.column(column).in(values));
1141        return (R) this;
1142    }
1143
1144
1145    /**
1146     * {@code IN(value)}
1147     *
1148     * @param column 列名
1149     * @param values 条件的值
1150     */
1151    @Override
1152    public R in(String column, Object[] values, boolean isEffective) {
1153        and(QueryMethods.column(column).in(values, isEffective));
1154        return (R) this;
1155    }
1156
1157    /**
1158     * {@code IN(value)}
1159     *
1160     * @param column 列名, lambda 展示
1161     * @param values 值
1162     */
1163    @Override
1164    public <T> R in(LambdaGetter<T> column, Object[] values, boolean isEffective) {
1165        and(QueryMethods.column(column).in(values, isEffective));
1166        return (R) this;
1167    }
1168
1169
1170    /**
1171     * {@code IN(value)}
1172     *
1173     * @param column 列名
1174     * @param values 条件的值
1175     */
1176    @Override
1177    public R in(String column, Collection<?> values, boolean isEffective) {
1178        and(QueryMethods.column(column).in(values, isEffective));
1179        return (R) this;
1180    }
1181
1182    /**
1183     * {@code IN(value)}
1184     *
1185     * @param column 列名, lambda 展示
1186     * @param values 值
1187     */
1188    @Override
1189    public <T> R in(LambdaGetter<T> column, Collection<?> values, boolean isEffective) {
1190        and(QueryMethods.column(column).in(values, isEffective));
1191        return (R) this;
1192    }
1193
1194
1195    /**
1196     * {@code IN(value)}
1197     *
1198     * @param column       列名
1199     * @param queryWrapper 条件的值
1200     */
1201    @Override
1202    public R in(String column, QueryWrapper queryWrapper, boolean isEffective) {
1203        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1204        return (R) this;
1205    }
1206
1207
1208    /**
1209     * {@code IN(value)}
1210     *
1211     * @param column       列名, lambda 展示
1212     * @param queryWrapper 值
1213     */
1214    @Override
1215    public <T> R in(LambdaGetter<T> column, QueryWrapper queryWrapper, boolean isEffective) {
1216        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1217        return (R) this;
1218    }
1219
1220
1221    /**
1222     * {@code IN(value)}
1223     *
1224     * @param column       列名
1225     * @param queryWrapper 条件的值
1226     */
1227    @Override
1228    public R in(String column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1229        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1230        return (R) this;
1231    }
1232
1233
1234    /**
1235     * {@code IN(value)}
1236     *
1237     * @param column       列名, lambda 展示
1238     * @param queryWrapper 值
1239     */
1240    @Override
1241    public <T> R in(LambdaGetter<T> column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1242        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1243        return (R) this;
1244    }
1245
1246
1247    /**
1248     * {@code NOT IN(value)}
1249     *
1250     * @param column 列名
1251     * @param values 条件的值
1252     */
1253    @Override
1254    public R notIn(String column, Object... values) {
1255        and(QueryMethods.column(column).notIn(values));
1256        return (R) this;
1257    }
1258
1259    /**
1260     * {@code NOT IN(value)}
1261     *
1262     * @param column 列名, lambda 展示
1263     * @param values 值
1264     */
1265    @Override
1266    public <T> R notIn(LambdaGetter<T> column, Object... values) {
1267        and(QueryMethods.column(column).notIn(values));
1268        return (R) this;
1269    }
1270
1271
1272    /**
1273     * {@code NOT IN(value)}
1274     *
1275     * @param column       列名
1276     * @param queryWrapper 条件的值
1277     */
1278    @Override
1279    public R notIn(String column, QueryWrapper queryWrapper) {
1280        and(QueryMethods.column(column).notIn(queryWrapper));
1281        return (R) this;
1282    }
1283
1284
1285    /**
1286     * {@code NOT IN(value)}
1287     *
1288     * @param column       列名, lambda 展示
1289     * @param queryWrapper 值
1290     */
1291    @Override
1292    public <T> R notIn(LambdaGetter<T> column, QueryWrapper queryWrapper) {
1293        and(QueryMethods.column(column).notIn(queryWrapper));
1294        return (R) this;
1295    }
1296
1297
1298    /**
1299     * {@code NOT IN(value)}
1300     *
1301     * @param column 列名
1302     * @param values 条件的值
1303     */
1304    @Override
1305    public R notIn(String column, Collection<?> values) {
1306        and(QueryMethods.column(column).notIn(values));
1307        return (R) this;
1308    }
1309
1310    /**
1311     * {@code NOT IN(value)}
1312     *
1313     * @param column 列名, lambda 展示
1314     * @param values 值
1315     */
1316    @Override
1317    public <T> R notIn(LambdaGetter<T> column, Collection<?> values) {
1318        and(QueryMethods.column(column).notIn(values));
1319        return (R) this;
1320    }
1321
1322
1323    /**
1324     * {@code NOT IN(value)}
1325     *
1326     * @param column 列名
1327     * @param values 条件的值
1328     */
1329    @Override
1330    public R notIn(String column, Object[] values, boolean isEffective) {
1331        and(QueryMethods.column(column).notIn(values, isEffective));
1332        return (R) this;
1333    }
1334
1335    /**
1336     * {@code NOT IN(value)}
1337     *
1338     * @param column 列名, lambda 展示
1339     * @param values 值
1340     */
1341    @Override
1342    public <T> R notIn(LambdaGetter<T> column, Object[] values, boolean isEffective) {
1343        and(QueryMethods.column(column).notIn(values, isEffective));
1344        return (R) this;
1345    }
1346
1347
1348    /**
1349     * {@code NOT IN(value)}
1350     *
1351     * @param column 列名
1352     * @param values 条件的值
1353     */
1354    @Override
1355    public R notIn(String column, Collection<?> values, boolean isEffective) {
1356        and(QueryMethods.column(column).notIn(values, isEffective));
1357        return (R) this;
1358    }
1359
1360    /**
1361     * {@code NOT IN(value)}
1362     *
1363     * @param column 列名, lambda 展示
1364     * @param values 值
1365     */
1366    @Override
1367    public <T> R notIn(LambdaGetter<T> column, Collection<?> values, boolean isEffective) {
1368        and(QueryMethods.column(column).notIn(values, isEffective));
1369        return (R) this;
1370    }
1371
1372
1373    /**
1374     * {@code NOT IN(value)}
1375     *
1376     * @param column       列名
1377     * @param queryWrapper 条件的值
1378     */
1379    @Override
1380    public R notIn(String column, QueryWrapper queryWrapper, boolean isEffective) {
1381        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1382        return (R) this;
1383    }
1384
1385
1386    /**
1387     * {@code NOT IN(value)}
1388     *
1389     * @param column       列名, lambda 展示
1390     * @param queryWrapper 值
1391     */
1392    @Override
1393    public <T> R notIn(LambdaGetter<T> column, QueryWrapper queryWrapper, boolean isEffective) {
1394        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1395        return (R) this;
1396    }
1397
1398
1399    /**
1400     * {@code NOT IN(value)}
1401     *
1402     * @param column       列名
1403     * @param queryWrapper 条件的值
1404     */
1405    @Override
1406    public R notIn(String column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1407        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1408        return (R) this;
1409    }
1410
1411
1412    /**
1413     * {@code NOT IN(value)}
1414     *
1415     * @param column       列名, lambda 展示
1416     * @param queryWrapper 值
1417     */
1418    @Override
1419    public <T> R notIn(LambdaGetter<T> column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1420        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1421        return (R) this;
1422    }
1423
1424
1425    /**
1426     * {@code BETWEEN start AND end}
1427     *
1428     * @param column 列名
1429     * @param start  开始的值
1430     * @param end    结束的值
1431     */
1432    @Override
1433    public R between(String column, Object start, Object end) {
1434        and(QueryMethods.column(column).between(start, end));
1435        return (R) this;
1436    }
1437
1438    /**
1439     * {@code BETWEEN start AND end}
1440     *
1441     * @param column 列名
1442     * @param start  开始的值
1443     * @param end    结束的值
1444     */
1445    @Override
1446    public <T> R between(LambdaGetter<T> column, Object start, Object end) {
1447        and(QueryMethods.column(column).between(start, end));
1448        return (R) this;
1449    }
1450
1451    /**
1452     * {@code BETWEEN start AND end}
1453     *
1454     * @param column 列名
1455     * @param start  开始的值
1456     * @param end    结束的值
1457     */
1458    @Override
1459    public R between(String column, Object start, Object end, boolean isEffective) {
1460        and(QueryMethods.column(column).between(start, end, isEffective));
1461        return (R) this;
1462    }
1463
1464    /**
1465     * {@code BETWEEN start AND end}
1466     *
1467     * @param column 列名
1468     * @param start  开始的值
1469     * @param end    结束的值
1470     */
1471    @Override
1472    public <T> R between(LambdaGetter<T> column, Object start, Object end, boolean isEffective) {
1473        and(QueryMethods.column(column).between(start, end, isEffective));
1474        return (R) this;
1475    }
1476
1477
1478    /**
1479     * {@code BETWEEN start AND end}
1480     *
1481     * @param column 列名
1482     * @param start  开始的值
1483     * @param end    结束的值
1484     */
1485    @Override
1486    public R between(String column, Object start, Object end, BooleanSupplier isEffective) {
1487        and(QueryMethods.column(column).between(start, end, isEffective));
1488        return (R) this;
1489    }
1490
1491    /**
1492     * {@code BETWEEN start AND end}
1493     *
1494     * @param column 列名
1495     * @param start  开始的值
1496     * @param end    结束的值
1497     */
1498    @Override
1499    public <T> R between(LambdaGetter<T> column, Object start, Object end, BooleanSupplier isEffective) {
1500        and(QueryMethods.column(column).between(start, end, isEffective));
1501        return (R) this;
1502    }
1503
1504
1505    /**
1506     * {@code NOT BETWEEN start AND end}
1507     *
1508     * @param column 列名
1509     * @param start  开始的值
1510     * @param end    结束的值
1511     */
1512    @Override
1513    public R notBetween(String column, Object start, Object end) {
1514        and(QueryMethods.column(column).notBetween(start, end));
1515        return (R) this;
1516    }
1517
1518    /**
1519     * {@code NOT BETWEEN start AND end}
1520     *
1521     * @param column 列名
1522     * @param start  开始的值
1523     * @param end    结束的值
1524     */
1525    @Override
1526    public <T> R notBetween(LambdaGetter<T> column, Object start, Object end) {
1527        and(QueryMethods.column(column).notBetween(start, end));
1528        return (R) this;
1529    }
1530
1531    /**
1532     * {@code NOT BETWEEN start AND end}
1533     *
1534     * @param column 列名
1535     * @param start  开始的值
1536     * @param end    结束的值
1537     */
1538    @Override
1539    public R notBetween(String column, Object start, Object end, boolean isEffective) {
1540        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1541        return (R) this;
1542    }
1543
1544    /**
1545     * {@code NOT BETWEEN start AND end}
1546     *
1547     * @param column 列名
1548     * @param start  开始的值
1549     * @param end    结束的值
1550     */
1551    @Override
1552    public <T> R notBetween(LambdaGetter<T> column, Object start, Object end, boolean isEffective) {
1553        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1554        return (R) this;
1555    }
1556
1557
1558    /**
1559     * {@code NOT BETWEEN start AND end}
1560     *
1561     * @param column 列名
1562     * @param start  开始的值
1563     * @param end    结束的值
1564     */
1565    @Override
1566    public R notBetween(String column, Object start, Object end, BooleanSupplier isEffective) {
1567        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1568        return (R) this;
1569    }
1570
1571    /**
1572     * {@code NOT BETWEEN start AND end}
1573     *
1574     * @param column 列名
1575     * @param start  开始的值
1576     * @param end    结束的值
1577     */
1578    @Override
1579    public <T> R notBetween(LambdaGetter<T> column, Object start, Object end, BooleanSupplier isEffective) {
1580        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1581        return (R) this;
1582    }
1583
1584
1585    /**
1586     * {@code LIKE %value%}
1587     *
1588     * @param column 列名
1589     * @param value  条件的值
1590     */
1591    @Override
1592    public R like(String column, Object value) {
1593        and(QueryMethods.column(column).like(value));
1594        return (R) this;
1595    }
1596
1597    /**
1598     * {@code LIKE %value%}
1599     *
1600     * @param column 列名, lambda 展示
1601     * @param value  值
1602     */
1603    @Override
1604    public <T> R like(LambdaGetter<T> column, Object value) {
1605        and(QueryMethods.column(column).like(value));
1606        return (R) this;
1607    }
1608
1609    /**
1610     * {@code LIKE %value%}
1611     *
1612     * @param column      列名
1613     * @param value       条件的值
1614     * @param isEffective 是否有效
1615     */
1616    @Override
1617    public R like(String column, Object value, boolean isEffective) {
1618        and(QueryMethods.column(column).like(value).when(isEffective));
1619        return (R) this;
1620    }
1621
1622    /**
1623     * {@code LIKE %value%}
1624     *
1625     * @param column      列名, lambda 展示
1626     * @param value       值
1627     * @param isEffective 是否有效
1628     */
1629    @Override
1630    public <T> R like(LambdaGetter<T> column, Object value, boolean isEffective) {
1631        and(QueryMethods.column(column).like(value).when(isEffective));
1632        return (R) this;
1633    }
1634
1635    /**
1636     * {@code LIKE %value%}
1637     *
1638     * @param column      列名
1639     * @param value       条件的值
1640     * @param isEffective 是否有效
1641     */
1642    @Override
1643    public <V> R like(String column, V value, Predicate<V> isEffective) {
1644        and(QueryMethods.column(column).like(value, isEffective));
1645        return (R) this;
1646    }
1647
1648    /**
1649     * {@code LIKE %value%}
1650     *
1651     * @param column      列名, lambda 展示
1652     * @param value       值
1653     * @param isEffective 是否有效
1654     */
1655    @Override
1656    public <T, V> R like(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1657        and(QueryMethods.column(column).like(value, isEffective));
1658        return (R) this;
1659    }
1660
1661
1662    /**
1663     * {@code LIKE value%}
1664     *
1665     * @param column 列名
1666     * @param value  条件的值
1667     */
1668    @Override
1669    public R likeLeft(String column, Object value) {
1670        and(QueryMethods.column(column).likeLeft(value));
1671        return (R) this;
1672    }
1673
1674    /**
1675     * {@code LIKE value%}
1676     *
1677     * @param column 列名, lambda 展示
1678     * @param value  值
1679     */
1680    @Override
1681    public <T> R likeLeft(LambdaGetter<T> column, Object value) {
1682        and(QueryMethods.column(column).likeLeft(value));
1683        return (R) this;
1684    }
1685
1686    /**
1687     * {@code LIKE value%}
1688     *
1689     * @param column      列名
1690     * @param value       条件的值
1691     * @param isEffective 是否有效
1692     */
1693    @Override
1694    public R likeLeft(String column, Object value, boolean isEffective) {
1695        and(QueryMethods.column(column).likeLeft(value).when(isEffective));
1696        return (R) this;
1697    }
1698
1699    /**
1700     * {@code LIKE value%}
1701     *
1702     * @param column      列名, lambda 展示
1703     * @param value       值
1704     * @param isEffective 是否有效
1705     */
1706    @Override
1707    public <T> R likeLeft(LambdaGetter<T> column, Object value, boolean isEffective) {
1708        and(QueryMethods.column(column).likeLeft(value).when(isEffective));
1709        return (R) this;
1710    }
1711
1712    /**
1713     * {@code LIKE value%}
1714     *
1715     * @param column      列名
1716     * @param value       条件的值
1717     * @param isEffective 是否有效
1718     */
1719    @Override
1720    public <V> R likeLeft(String column, V value, Predicate<V> isEffective) {
1721        and(QueryMethods.column(column).likeLeft(value, isEffective));
1722        return (R) this;
1723    }
1724
1725    /**
1726     * {@code LIKE value%}
1727     *
1728     * @param column      列名, lambda 展示
1729     * @param value       值
1730     * @param isEffective 是否有效
1731     */
1732    @Override
1733    public <T, V> R likeLeft(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1734        and(QueryMethods.column(column).likeLeft(value, isEffective));
1735        return (R) this;
1736    }
1737
1738
1739    /**
1740     * {@code LIKE %value}
1741     *
1742     * @param column 列名
1743     * @param value  条件的值
1744     */
1745    @Override
1746    public R likeRight(String column, Object value) {
1747        and(QueryMethods.column(column).likeRight(value));
1748        return (R) this;
1749    }
1750
1751    /**
1752     * {@code LIKE %value}
1753     *
1754     * @param column 列名, lambda 展示
1755     * @param value  值
1756     */
1757    @Override
1758    public <T> R likeRight(LambdaGetter<T> column, Object value) {
1759        and(QueryMethods.column(column).likeRight(value));
1760        return (R) this;
1761    }
1762
1763    /**
1764     * {@code LIKE %value}
1765     *
1766     * @param column      列名
1767     * @param value       条件的值
1768     * @param isEffective 是否有效
1769     */
1770    @Override
1771    public R likeRight(String column, Object value, boolean isEffective) {
1772        and(QueryMethods.column(column).likeRight(value).when(isEffective));
1773        return (R) this;
1774    }
1775
1776    /**
1777     * {@code LIKE %value}
1778     *
1779     * @param column      列名, lambda 展示
1780     * @param value       值
1781     * @param isEffective 是否有效
1782     */
1783    @Override
1784    public <T> R likeRight(LambdaGetter<T> column, Object value, boolean isEffective) {
1785        and(QueryMethods.column(column).likeRight(value).when(isEffective));
1786        return (R) this;
1787    }
1788
1789    /**
1790     * {@code LIKE %value}
1791     *
1792     * @param column      列名
1793     * @param value       条件的值
1794     * @param isEffective 是否有效
1795     */
1796    @Override
1797    public <V> R likeRight(String column, V value, Predicate<V> isEffective) {
1798        and(QueryMethods.column(column).likeRight(value, isEffective));
1799        return (R) this;
1800    }
1801
1802    /**
1803     * {@code LIKE %value}
1804     *
1805     * @param column      列名, lambda 展示
1806     * @param value       值
1807     * @param isEffective 是否有效
1808     */
1809    @Override
1810    public <T, V> R likeRight(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1811        and(QueryMethods.column(column).likeRight(value, isEffective));
1812        return (R) this;
1813    }
1814
1815
1816    /**
1817     * {@code NOT LIKE %value%}
1818     *
1819     * @param column 列名
1820     * @param value  条件的值
1821     */
1822    @Override
1823    public R notLike(String column, Object value) {
1824        and(QueryMethods.column(column).notLike(value));
1825        return (R) this;
1826    }
1827
1828    /**
1829     * {@code NOT LIKE %value%}
1830     *
1831     * @param column 列名, lambda 展示
1832     * @param value  值
1833     */
1834    @Override
1835    public <T> R notLike(LambdaGetter<T> column, Object value) {
1836        and(QueryMethods.column(column).notLike(value));
1837        return (R) this;
1838    }
1839
1840    /**
1841     * {@code NOT LIKE %value%}
1842     *
1843     * @param column      列名
1844     * @param value       条件的值
1845     * @param isEffective 是否有效
1846     */
1847    @Override
1848    public R notLike(String column, Object value, boolean isEffective) {
1849        and(QueryMethods.column(column).notLike(value).when(isEffective));
1850        return (R) this;
1851    }
1852
1853    /**
1854     * {@code NOT LIKE %value%}
1855     *
1856     * @param column      列名, lambda 展示
1857     * @param value       值
1858     * @param isEffective 是否有效
1859     */
1860    @Override
1861    public <T> R notLike(LambdaGetter<T> column, Object value, boolean isEffective) {
1862        and(QueryMethods.column(column).notLike(value).when(isEffective));
1863        return (R) this;
1864    }
1865
1866    /**
1867     * {@code NOT LIKE %value%}
1868     *
1869     * @param column      列名
1870     * @param value       条件的值
1871     * @param isEffective 是否有效
1872     */
1873    @Override
1874    public <V> R notLike(String column, V value, Predicate<V> isEffective) {
1875        and(QueryMethods.column(column).notLike(value, isEffective));
1876        return (R) this;
1877    }
1878
1879    /**
1880     * {@code NOT LIKE %value%}
1881     *
1882     * @param column      列名, lambda 展示
1883     * @param value       值
1884     * @param isEffective 是否有效
1885     */
1886    @Override
1887    public <T, V> R notLike(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1888        and(QueryMethods.column(column).notLike(value, isEffective));
1889        return (R) this;
1890    }
1891
1892
1893    /**
1894     * {@code NOT LIKE value%}
1895     *
1896     * @param column 列名
1897     * @param value  条件的值
1898     */
1899    @Override
1900    public R notLikeLeft(String column, Object value) {
1901        and(QueryMethods.column(column).notLikeLeft(value));
1902        return (R) this;
1903    }
1904
1905    /**
1906     * {@code NOT LIKE value%}
1907     *
1908     * @param column 列名, lambda 展示
1909     * @param value  值
1910     */
1911    @Override
1912    public <T> R notLikeLeft(LambdaGetter<T> column, Object value) {
1913        and(QueryMethods.column(column).notLikeLeft(value));
1914        return (R) this;
1915    }
1916
1917    /**
1918     * {@code NOT LIKE value%}
1919     *
1920     * @param column      列名
1921     * @param value       条件的值
1922     * @param isEffective 是否有效
1923     */
1924    @Override
1925    public R notLikeLeft(String column, Object value, boolean isEffective) {
1926        and(QueryMethods.column(column).notLikeLeft(value).when(isEffective));
1927        return (R) this;
1928    }
1929
1930    /**
1931     * {@code NOT LIKE value%}
1932     *
1933     * @param column      列名, lambda 展示
1934     * @param value       值
1935     * @param isEffective 是否有效
1936     */
1937    @Override
1938    public <T> R notLikeLeft(LambdaGetter<T> column, Object value, boolean isEffective) {
1939        and(QueryMethods.column(column).notLikeLeft(value).when(isEffective));
1940        return (R) this;
1941    }
1942
1943    /**
1944     * {@code NOT LIKE value%}
1945     *
1946     * @param column      列名
1947     * @param value       条件的值
1948     * @param isEffective 是否有效
1949     */
1950    @Override
1951    public <V> R notLikeLeft(String column, V value, Predicate<V> isEffective) {
1952        and(QueryMethods.column(column).notLikeLeft(value, isEffective));
1953        return (R) this;
1954    }
1955
1956    /**
1957     * {@code NOT LIKE value%}
1958     *
1959     * @param column      列名, lambda 展示
1960     * @param value       值
1961     * @param isEffective 是否有效
1962     */
1963    @Override
1964    public <T, V> R notLikeLeft(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1965        and(QueryMethods.column(column).notLikeLeft(value, isEffective));
1966        return (R) this;
1967    }
1968
1969
1970    /**
1971     * {@code NOT LIKE %value}
1972     *
1973     * @param column 列名
1974     * @param value  条件的值
1975     */
1976    @Override
1977    public R notLikeRight(String column, Object value) {
1978        and(QueryMethods.column(column).notLikeRight(value));
1979        return (R) this;
1980    }
1981
1982    /**
1983     * {@code NOT LIKE %value}
1984     *
1985     * @param column 列名, lambda 展示
1986     * @param value  值
1987     */
1988    @Override
1989    public <T> R notLikeRight(LambdaGetter<T> column, Object value) {
1990        and(QueryMethods.column(column).notLikeRight(value));
1991        return (R) this;
1992    }
1993
1994    /**
1995     * {@code NOT LIKE %value}
1996     *
1997     * @param column      列名
1998     * @param value       条件的值
1999     * @param isEffective 是否有效
2000     */
2001    @Override
2002    public R notLikeRight(String column, Object value, boolean isEffective) {
2003        and(QueryMethods.column(column).notLikeRight(value).when(isEffective));
2004        return (R) this;
2005    }
2006
2007    /**
2008     * {@code NOT LIKE %value}
2009     *
2010     * @param column      列名, lambda 展示
2011     * @param value       值
2012     * @param isEffective 是否有效
2013     */
2014    @Override
2015    public <T> R notLikeRight(LambdaGetter<T> column, Object value, boolean isEffective) {
2016        and(QueryMethods.column(column).notLikeRight(value).when(isEffective));
2017        return (R) this;
2018    }
2019
2020    /**
2021     * {@code NOT LIKE %value}
2022     *
2023     * @param column      列名
2024     * @param value       条件的值
2025     * @param isEffective 是否有效
2026     */
2027    @Override
2028    public <V> R notLikeRight(String column, V value, Predicate<V> isEffective) {
2029        and(QueryMethods.column(column).notLikeRight(value, isEffective));
2030        return (R) this;
2031    }
2032
2033    /**
2034     * {@code NOT LIKE %value}
2035     *
2036     * @param column      列名, lambda 展示
2037     * @param value       值
2038     * @param isEffective 是否有效
2039     */
2040    @Override
2041    public <T, V> R notLikeRight(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
2042        and(QueryMethods.column(column).notLikeRight(value, isEffective));
2043        return (R) this;
2044    }
2045
2046
2047    /**
2048     * {@code IS NULL}
2049     *
2050     * @param column 列名
2051     */
2052    @Override
2053    public R isNull(String column) {
2054        and(QueryMethods.column(column).isNull());
2055        return (R) this;
2056    }
2057
2058    /**
2059     * {@code IS NULL}
2060     *
2061     * @param column 列名, lambda 展示
2062     */
2063    @Override
2064    public <T> R isNull(LambdaGetter<T> column) {
2065        and(QueryMethods.column(column).isNull());
2066        return (R) this;
2067    }
2068
2069    /**
2070     * {@code IS NULL}
2071     *
2072     * @param column      列名
2073     * @param isEffective 是否有效
2074     */
2075    @Override
2076    public R isNull(String column, boolean isEffective) {
2077        and(QueryMethods.column(column).isNull(isEffective));
2078        return (R) this;
2079    }
2080
2081    /**
2082     * {@code IS NULL}
2083     *
2084     * @param column      列名, lambda 展示
2085     * @param isEffective 是否有效
2086     */
2087    @Override
2088    public <T> R isNull(LambdaGetter<T> column, boolean isEffective) {
2089        and(QueryMethods.column(column).isNull(isEffective));
2090        return (R) this;
2091    }
2092
2093    /**
2094     * {@code IS NULL}
2095     *
2096     * @param column      列名
2097     * @param isEffective 是否有效
2098     */
2099    @Override
2100    public R isNull(String column, BooleanSupplier isEffective) {
2101        and(QueryMethods.column(column).isNull(isEffective));
2102        return (R) this;
2103    }
2104
2105    /**
2106     * {@code IS NULL}
2107     *
2108     * @param column      列名, lambda 展示
2109     * @param isEffective 是否有效
2110     */
2111    @Override
2112    public <T> R isNull(LambdaGetter<T> column, BooleanSupplier isEffective) {
2113        and(QueryMethods.column(column).isNull(isEffective));
2114        return (R) this;
2115    }
2116
2117
2118    /**
2119     * {@code IS NOT NULL}
2120     *
2121     * @param column 列名
2122     */
2123    @Override
2124    public R isNotNull(String column) {
2125        and(QueryMethods.column(column).isNotNull());
2126        return (R) this;
2127    }
2128
2129    /**
2130     * {@code IS NOT NULL}
2131     *
2132     * @param column 列名, lambda 展示
2133     */
2134    @Override
2135    public <T> R isNotNull(LambdaGetter<T> column) {
2136        and(QueryMethods.column(column).isNotNull());
2137        return (R) this;
2138    }
2139
2140    /**
2141     * {@code IS NOT NULL}
2142     *
2143     * @param column      列名
2144     * @param isEffective 是否有效
2145     */
2146    @Override
2147    public R isNotNull(String column, boolean isEffective) {
2148        and(QueryMethods.column(column).isNotNull(isEffective));
2149        return (R) this;
2150    }
2151
2152    /**
2153     * {@code IS NOT NULL}
2154     *
2155     * @param column      列名, lambda 展示
2156     * @param isEffective 是否有效
2157     */
2158    @Override
2159    public <T> R isNotNull(LambdaGetter<T> column, boolean isEffective) {
2160        and(QueryMethods.column(column).isNotNull(isEffective));
2161        return (R) this;
2162    }
2163
2164    /**
2165     * {@code IS NOT NULL}
2166     *
2167     * @param column      列名
2168     * @param isEffective 是否有效
2169     */
2170    @Override
2171    public R isNotNull(String column, BooleanSupplier isEffective) {
2172        and(QueryMethods.column(column).isNotNull(isEffective));
2173        return (R) this;
2174    }
2175
2176    /**
2177     * {@code IS NOT NULL}
2178     *
2179     * @param column      列名, lambda 展示
2180     * @param isEffective 是否有效
2181     */
2182    @Override
2183    public <T> R isNotNull(LambdaGetter<T> column, BooleanSupplier isEffective) {
2184        and(QueryMethods.column(column).isNotNull(isEffective));
2185        return (R) this;
2186    }
2187
2188
2189    @Override
2190    public R clone() {
2191        return (R) super.clone();
2192    }
2193
2194}