源代码

001/*
002 *  Copyright (c) 2022-2024, 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.FlexConsts;
019import com.mybatisflex.core.constant.SqlConnector;
020import com.mybatisflex.core.constant.SqlConsts;
021import com.mybatisflex.core.constant.SqlOperator;
022import com.mybatisflex.core.dialect.DialectFactory;
023import com.mybatisflex.core.table.TableInfo;
024import com.mybatisflex.core.table.TableInfoFactory;
025import com.mybatisflex.core.util.ArrayUtil;
026import com.mybatisflex.core.util.ClassUtil;
027import com.mybatisflex.core.util.CollectionUtil;
028import com.mybatisflex.core.util.LambdaGetter;
029import com.mybatisflex.core.util.LambdaUtil;
030import com.mybatisflex.core.util.SqlUtil;
031import com.mybatisflex.core.util.StringUtil;
032
033import java.util.ArrayList;
034import java.util.Arrays;
035import java.util.Collection;
036import java.util.Collections;
037import java.util.List;
038import java.util.Map;
039import java.util.function.BooleanSupplier;
040import java.util.function.Consumer;
041import java.util.function.Predicate;
042
043public class QueryWrapper extends BaseQueryWrapper<QueryWrapper> {
044
045    public static QueryWrapper create() {
046        return new QueryWrapper();
047    }
048
049    /**
050     * 根据实体类对象，构建查询条件
051     *
052     * @param entity 实体类对象
053     * @return 查询对象 QueryWrapper
054     */
055    public static QueryWrapper create(Object entity) {
056        TableInfo tableInfo = TableInfoFactory.ofEntityClass(ClassUtil.getUsefulClass(entity.getClass()));
057        return tableInfo.buildQueryWrapper(entity, null);
058    }
059
060    /**
061     * 根据实体类构建查询条件
062     *
063     * @param entity    实体类对象
064     * @param operators 每个属性对应的操作符
065     * @return 查询对象 QueryWrapper
066     */
067    public static QueryWrapper create(Object entity, SqlOperators operators) {
068        TableInfo tableInfo = TableInfoFactory.ofEntityClass(ClassUtil.getUsefulClass(entity.getClass()));
069        return tableInfo.buildQueryWrapper(entity, operators);
070    }
071
072    /**
073     * 根据 Map 对象，构建查询条件
074     *
075     * @param map Map 对象
076     * @return 查询对象 QueryWrapper
077     */
078    public static QueryWrapper create(Map map) {
079        return create().where(map);
080    }
081
082    /**
083     * 根据 Map 构建查询条件
084     *
085     * @param map       Map 对象
086     * @param operators 每个属性对应的操作符
087     * @return 查询对象 QueryWrapper
088     */
089    public static QueryWrapper create(Map map, SqlOperators operators) {
090        return create().where(map, operators);
091    }
092
093    /**
094     * <p>判断当前 {@link QueryWrapper} 是否包含 {@code WHERE} 查询条件。
095     *
096     * <p>需要判断的查询条件，只包括主动构建的查询条件，不包括追加的条件，例如：逻辑删除功能自动添加的
097     * {@code is_delete = 0} 不会包含在检查条件内。
098     *
099     * @return {@code true} 包含条件，{@code false} 不包含条件。
100     */
101    public boolean hasCondition() {
102        QueryCondition c;
103        return (c = whereQueryCondition) != null && (c.checkEffective() || c.getNextEffectiveCondition() != null);
104    }
105
106    @SuppressWarnings("unchecked")
107    public <Q extends QueryWrapper> WithBuilder<Q> with(String name) {
108        if (with == null) {
109            with = new With();
110        }
111        return new WithBuilder<>((Q) this, with, name);
112    }
113
114    @SuppressWarnings("unchecked")
115    public <Q extends QueryWrapper> WithBuilder<Q> with(String name, String... params) {
116        if (with == null) {
117            with = new With();
118        }
119        return new WithBuilder<>((Q) this, with, name, Arrays.asList(params));
120    }
121
122    @SuppressWarnings("unchecked")
123    public <Q extends QueryWrapper> WithBuilder<Q> withRecursive(String name) {
124        if (with == null) {
125            with = new With(true);
126        }
127        return new WithBuilder<>((Q) this, with, name);
128    }
129
130    @SuppressWarnings("unchecked")
131    public <Q extends QueryWrapper> WithBuilder<Q> withRecursive(String name, String... params) {
132        if (with == null) {
133            with = new With(true);
134        }
135        return new WithBuilder<>((Q) this, with, name, Arrays.asList(params));
136    }
137
138    public QueryWrapper select() {
139        return this;
140    }
141
142    public QueryWrapper select(String... columns) {
143        for (String column : columns) {
144            addSelectColumn(new RawQueryColumn(column));
145        }
146        return this;
147    }
148
149    public <T> QueryWrapper select(LambdaGetter<T>... lambdaGetters) {
150        for (LambdaGetter<?> lambdaGetter : lambdaGetters) {
151            QueryColumn queryColumn = LambdaUtil.getQueryColumn(lambdaGetter);
152            addSelectColumn(queryColumn);
153        }
154        return this;
155    }
156
157    public QueryWrapper select(QueryColumn... queryColumns) {
158        for (QueryColumn column : queryColumns) {
159            if (column != null) {
160                addSelectColumn(column);
161            }
162        }
163        return this;
164    }
165
166    public QueryWrapper select(Iterable<QueryColumn> queryColumns) {
167        for (QueryColumn column : queryColumns) {
168            if (column != null) {
169                addSelectColumn(column);
170            }
171        }
172        return this;
173    }
174
175    public QueryWrapper select(QueryColumn[]... queryColumns) {
176        for (QueryColumn[] columnArray : queryColumns) {
177            if (columnArray != null) {
178                for (QueryColumn column : columnArray) {
179                    if (column != null) {
180                        addSelectColumn(column);
181                    }
182                }
183            }
184        }
185        return this;
186    }
187
188    public QueryWrapper select(QueryColumn[] queryColumns, QueryColumn... queryColumns2) {
189        for (QueryColumn column : queryColumns) {
190            if (column != null) {
191                addSelectColumn(column);
192            }
193        }
194        for (QueryColumn column : queryColumns2) {
195            if (column != null) {
196                addSelectColumn(column);
197            }
198        }
199        return this;
200    }
201
202    public QueryWrapper from(Class<?>... entityClasses) {
203        for (Class<?> entityClass : entityClasses) {
204            TableInfo tableInfo = TableInfoFactory.ofEntityClass(entityClass);
205            from(new QueryTable(tableInfo.getSchema(), tableInfo.getTableName()));
206        }
207        return this;
208    }
209
210    public QueryWrapper from(String... tables) {
211        for (String table : tables) {
212            if (StringUtil.isBlank(table)) {
213                throw new IllegalArgumentException("table must not be null or blank.");
214            }
215            from(new QueryTable(table));
216        }
217        return this;
218    }
219
220    public QueryWrapper from(QueryTable... tables) {
221        if (CollectionUtil.isEmpty(queryTables)) {
222            queryTables = new ArrayList<>();
223            queryTables.addAll(Arrays.asList(tables));
224        } else {
225            for (QueryTable table : tables) {
226                boolean contains = false;
227                for (QueryTable queryTable : queryTables) {
228                    if (queryTable.isSameTable(table)) {
229                        contains = true;
230                    }
231                }
232                if (!contains) {
233                    queryTables.add(table);
234                }
235            }
236        }
237        return this;
238    }
239
240    public QueryWrapper from(QueryWrapper queryWrapper) {
241        return from(new SelectQueryTable(queryWrapper));
242    }
243
244    /**
245     * <p>为 FROM 语句后的第一个表起别名，而不是为整个 SELECT 语句起别名。
246     *
247     * <p>例如：以下示例，
248     *
249     * <p><pre>{@code
250     * QueryWrapper.create().from(ACCOUNT).as("a");
251     * }</pre>
252     *
253     * <p>等价于，
254     *
255     * <p><pre>{@code
256     * QueryWrapper.create().from(ACCOUNT.as("a"));
257     * }</pre>
258     *
259     * <p>最终生成的 SQL 为，
260     * <p><pre>{@code
261     * SELECT a.* FROM tb_account a
262     * }</pre>
263     *
264     * <p>而不是，
265     *
266     * <p><pre>{@code
267     * (SELECT * FROM tb_account) AS "a"
268     * }</pre>
269     *
270     * @param alias 别名
271     * @return 当前查询包装器
272     */
273    public QueryWrapper as(String alias) {
274        if (CollectionUtil.isEmpty(queryTables)) {
275            throw new IllegalArgumentException("query table must not be empty.");
276        }
277        int index = queryTables.size() - 1;
278        queryTables.set(index, queryTables.get(index).as(alias));
279        return this;
280    }
281
282    public QueryWrapper where(QueryCondition queryCondition) {
283        this.addWhereQueryCondition(queryCondition);
284        return this;
285    }
286
287    public QueryWrapper where(String sql) {
288        this.addWhereQueryCondition(new RawQueryCondition(sql));
289        return this;
290    }
291
292    public QueryWrapper where(String sql, Object... params) {
293        this.addWhereQueryCondition(new RawQueryCondition(sql, params));
294        return this;
295    }
296
297    public QueryWrapper where(Map<String, Object> whereConditions) {
298        return and(whereConditions);
299    }
300
301    public QueryWrapper where(Map<String, Object> whereConditions, SqlOperators operators) {
302        return and(whereConditions, operators);
303    }
304
305    public <T> QueryConditionBuilder<? extends QueryWrapper> where(LambdaGetter<T> fn) {
306        return new QueryConditionBuilder<>(this, LambdaUtil.getQueryColumn(fn), SqlConnector.AND);
307    }
308
309    public QueryWrapper where(Consumer<QueryWrapper> consumer) {
310        return and(consumer);
311    }
312
313    public QueryWrapper and(QueryCondition queryCondition) {
314        return addWhereQueryCondition(queryCondition, SqlConnector.AND);
315    }
316
317    public QueryWrapper and(String sql) {
318        this.addWhereQueryCondition(new RawQueryCondition(sql), SqlConnector.AND);
319        return this;
320    }
321
322    public QueryWrapper and(String sql, Object... params) {
323        this.addWhereQueryCondition(new RawQueryCondition(sql, params), SqlConnector.AND);
324        return this;
325    }
326
327    public <T> QueryConditionBuilder<? extends QueryWrapper> and(LambdaGetter<T> fn) {
328        return new QueryConditionBuilder<>(this, LambdaUtil.getQueryColumn(fn), SqlConnector.AND);
329    }
330
331    public QueryWrapper and(Consumer<QueryWrapper> consumer) {
332        return and(consumer, true);
333    }
334
335    public QueryWrapper and(Consumer<QueryWrapper> consumer, boolean condition) {
336        if (!condition) {
337            return this;
338        }
339        QueryWrapper newWrapper = new QueryWrapper();
340        consumer.accept(newWrapper);
341        QueryCondition whereQueryCondition = newWrapper.whereQueryCondition;
342        if (whereQueryCondition != null) {
343            and(new Brackets(whereQueryCondition));
344        }
345        return this;
346    }
347
348
349    public QueryWrapper and(Map<String, Object> whereConditions) {
350        return and(whereConditions, SqlOperators.empty());
351    }
352
353    public QueryWrapper and(Map<String, Object> whereConditions, SqlOperators operators) {
354        return connectMap(whereConditions, operators, SqlConnector.AND, SqlConnector.AND);
355    }
356
357    public QueryWrapper and(Map<String, Object> whereConditions, SqlOperators operators, SqlConnector innerConnector) {
358        return connectMap(whereConditions, operators, SqlConnector.AND, innerConnector);
359    }
360
361
362    public QueryWrapper or(QueryCondition queryCondition) {
363        return addWhereQueryCondition(queryCondition, SqlConnector.OR);
364    }
365
366    public QueryWrapper or(String sql) {
367        this.addWhereQueryCondition(new RawQueryCondition(sql), SqlConnector.OR);
368        return this;
369    }
370
371    public QueryWrapper or(String sql, Object... params) {
372        this.addWhereQueryCondition(new RawQueryCondition(sql, params), SqlConnector.OR);
373        return this;
374    }
375
376    public <T> QueryConditionBuilder<? extends QueryWrapper> or(LambdaGetter<T> fn) {
377        return new QueryConditionBuilder<>(this, LambdaUtil.getQueryColumn(fn), SqlConnector.OR);
378    }
379
380    public QueryWrapper or(Consumer<QueryWrapper> consumer) {
381        return or(consumer, true);
382    }
383
384    public QueryWrapper or(Consumer<QueryWrapper> consumer, boolean condition) {
385        if (!condition) {
386            return this;
387        }
388        QueryWrapper newWrapper = new QueryWrapper();
389        consumer.accept(newWrapper);
390        QueryCondition whereQueryCondition = newWrapper.whereQueryCondition;
391        if (whereQueryCondition != null) {
392            or(new Brackets(whereQueryCondition));
393        }
394        return this;
395    }
396
397    public QueryWrapper or(Map<String, Object> whereConditions) {
398        return or(whereConditions, SqlOperators.empty());
399    }
400
401    public QueryWrapper or(Map<String, Object> whereConditions, SqlOperators operators) {
402        return connectMap(whereConditions, operators, SqlConnector.OR, SqlConnector.AND);
403    }
404
405    public QueryWrapper or(Map<String, Object> whereConditions, SqlOperators operators, SqlConnector innerConnector) {
406        return connectMap(whereConditions, operators, SqlConnector.OR, innerConnector);
407    }
408
409    protected QueryWrapper connectMap(Map<String, Object> mapConditions, SqlOperators operators, SqlConnector outerConnector, SqlConnector innerConnector) {
410        if (operators == null) {
411            operators = SqlOperators.empty();
412        }
413        if (mapConditions != null) {
414            QueryTable table = null;
415            // 默认就是第一个表，可能为 null
416            if (CollectionUtil.isNotEmpty(queryTables)) {
417                table = queryTables.get(0);
418            }
419            QueryCondition condition = null;
420            for (Map.Entry<String, Object> entry : mapConditions.entrySet()) {
421                SqlOperator operator = operators.get(entry.getKey());
422                if (operator == null) {
423                    operator = SqlOperator.EQUALS;
424                } else if (operator == SqlOperator.IGNORE) {
425                    continue;
426                }
427                Object value = entry.getValue();
428                if (operator == SqlOperator.LIKE || operator == SqlOperator.NOT_LIKE) {
429                    value = "%" + value + "%";
430                } else if (operator == SqlOperator.LIKE_LEFT || operator == SqlOperator.NOT_LIKE_LEFT) {
431                    value = value + "%";
432                } else if (operator == SqlOperator.LIKE_RIGHT || operator == SqlOperator.NOT_LIKE_RIGHT) {
433                    value = "%" + value;
434                }
435                QueryCondition cond = QueryCondition.create(new QueryColumn(table, entry.getKey()), operator, value);
436                if (condition == null) {
437                    condition = cond;
438                } else {
439                    if (innerConnector == SqlConnector.AND) {
440                        condition.and(cond);
441                    } else {
442                        condition.or(cond);
443                    }
444                }
445            }
446            addWhereQueryCondition(condition, outerConnector);
447        }
448        return this;
449    }
450
451    public <Q extends QueryWrapper> Joiner<Q> leftJoin(QueryTable table) {
452        return joining(SqlConsts.LEFT_JOIN, table, true);
453    }
454
455    public <Q extends QueryWrapper> Joiner<Q> leftJoin(String table) {
456        return joining(SqlConsts.LEFT_JOIN, new QueryTable(table), true);
457    }
458
459    public <Q extends QueryWrapper> Joiner<Q> leftJoin(String table, boolean when) {
460        return joining(SqlConsts.LEFT_JOIN, new QueryTable(table), when);
461    }
462
463    public <Q extends QueryWrapper> Joiner<Q> leftJoin(Class<?> entityClass) {
464        return joining(SqlConsts.LEFT_JOIN, entityClass, true);
465    }
466
467    public <Q extends QueryWrapper> Joiner<Q> leftJoin(Class<?> entityClass, boolean when) {
468        return joining(SqlConsts.LEFT_JOIN, entityClass, when);
469    }
470
471    public <Q extends QueryWrapper> Joiner<Q> leftJoin(QueryWrapper table) {
472        return joining(SqlConsts.LEFT_JOIN, table, true);
473    }
474
475    public <Q extends QueryWrapper> Joiner<Q> leftJoin(QueryWrapper table, boolean when) {
476        return joining(SqlConsts.LEFT_JOIN, table, when);
477    }
478
479    public <Q extends QueryWrapper> Joiner<Q> rightJoin(QueryTable table) {
480        return joining(SqlConsts.RIGHT_JOIN, table, true);
481    }
482
483    public <Q extends QueryWrapper> Joiner<Q> rightJoin(String table) {
484        return joining(SqlConsts.RIGHT_JOIN, new QueryTable(table), true);
485    }
486
487    public <Q extends QueryWrapper> Joiner<Q> rightJoin(String table, boolean when) {
488        return joining(SqlConsts.RIGHT_JOIN, new QueryTable(table), when);
489    }
490
491    public <Q extends QueryWrapper> Joiner<Q> rightJoin(Class<?> entityClass) {
492        return joining(SqlConsts.RIGHT_JOIN, entityClass, true);
493    }
494
495    public <Q extends QueryWrapper> Joiner<Q> rightJoin(Class<?> entityClass, boolean when) {
496        return joining(SqlConsts.RIGHT_JOIN, entityClass, when);
497    }
498
499    public <Q extends QueryWrapper> Joiner<Q> rightJoin(QueryWrapper table) {
500        return joining(SqlConsts.RIGHT_JOIN, table, true);
501    }
502
503    public <Q extends QueryWrapper> Joiner<Q> rightJoin(QueryWrapper table, boolean when) {
504        return joining(SqlConsts.RIGHT_JOIN, table, when);
505    }
506
507    public <Q extends QueryWrapper> Joiner<Q> innerJoin(QueryTable table) {
508        return joining(SqlConsts.INNER_JOIN, table, true);
509    }
510
511    public <Q extends QueryWrapper> Joiner<Q> innerJoin(String table) {
512        return joining(SqlConsts.INNER_JOIN, new QueryTable(table), true);
513    }
514
515    public <Q extends QueryWrapper> Joiner<Q> innerJoin(String table, boolean when) {
516        return joining(SqlConsts.INNER_JOIN, new QueryTable(table), when);
517    }
518
519    public <Q extends QueryWrapper> Joiner<Q> innerJoin(Class<?> entityClass) {
520        return joining(SqlConsts.INNER_JOIN, entityClass, true);
521    }
522
523    public <Q extends QueryWrapper> Joiner<Q> innerJoin(Class<?> entityClass, boolean when) {
524        return joining(SqlConsts.INNER_JOIN, entityClass, when);
525    }
526
527    public <Q extends QueryWrapper> Joiner<Q> innerJoin(QueryWrapper table) {
528        return joining(SqlConsts.INNER_JOIN, table, true);
529    }
530
531    public <Q extends QueryWrapper> Joiner<Q> innerJoin(QueryWrapper table, boolean when) {
532        return joining(SqlConsts.INNER_JOIN, table, when);
533    }
534
535    public <Q extends QueryWrapper> Joiner<Q> fullJoin(QueryTable table) {
536        return joining(SqlConsts.FULL_JOIN, table, true);
537    }
538
539    public <Q extends QueryWrapper> Joiner<Q> fullJoin(String table) {
540        return joining(SqlConsts.FULL_JOIN, new QueryTable(table), true);
541    }
542
543    public <Q extends QueryWrapper> Joiner<Q> fullJoin(String table, boolean when) {
544        return joining(SqlConsts.FULL_JOIN, new QueryTable(table), when);
545    }
546
547    public <Q extends QueryWrapper> Joiner<Q> fullJoin(Class<?> entityClass) {
548        return joining(SqlConsts.FULL_JOIN, entityClass, true);
549    }
550
551    public <Q extends QueryWrapper> Joiner<Q> fullJoin(Class<?> entityClass, boolean when) {
552        return joining(SqlConsts.FULL_JOIN, entityClass, when);
553    }
554
555    public <Q extends QueryWrapper> Joiner<Q> fullJoin(QueryWrapper table) {
556        return joining(SqlConsts.FULL_JOIN, table, true);
557    }
558
559    public <Q extends QueryWrapper> Joiner<Q> fullJoin(QueryWrapper table, boolean when) {
560        return joining(SqlConsts.FULL_JOIN, table, when);
561    }
562
563    public <Q extends QueryWrapper> Joiner<Q> crossJoin(QueryTable table) {
564        return joining(SqlConsts.CROSS_JOIN, table, true);
565    }
566
567    public <Q extends QueryWrapper> Joiner<Q> crossJoin(String table) {
568        return joining(SqlConsts.CROSS_JOIN, new QueryTable(table), true);
569    }
570
571    public <Q extends QueryWrapper> Joiner<Q> crossJoin(String table, boolean when) {
572        return joining(SqlConsts.CROSS_JOIN, new QueryTable(table), when);
573    }
574
575    public <Q extends QueryWrapper> Joiner<Q> crossJoin(Class<?> entityClass) {
576        return joining(SqlConsts.CROSS_JOIN, entityClass, true);
577    }
578
579    public <Q extends QueryWrapper> Joiner<Q> crossJoin(Class<?> entityClass, boolean when) {
580        return joining(SqlConsts.CROSS_JOIN, entityClass, when);
581    }
582
583    public <Q extends QueryWrapper> Joiner<Q> crossJoin(QueryWrapper table) {
584        return joining(SqlConsts.CROSS_JOIN, table, true);
585    }
586
587    public <Q extends QueryWrapper> Joiner<Q> crossJoin(QueryWrapper table, boolean when) {
588        return joining(SqlConsts.CROSS_JOIN, table, when);
589    }
590
591    public <Q extends QueryWrapper> Joiner<Q> join(QueryTable table) {
592        return joining(SqlConsts.JOIN, table, true);
593    }
594
595    public <Q extends QueryWrapper> Joiner<Q> join(String table) {
596        return joining(SqlConsts.JOIN, new QueryTable(table), true);
597    }
598
599    public <Q extends QueryWrapper> Joiner<Q> join(String table, boolean when) {
600        return joining(SqlConsts.JOIN, new QueryTable(table), when);
601    }
602
603    public <Q extends QueryWrapper> Joiner<Q> join(Class<?> entityClass) {
604        return joining(SqlConsts.JOIN, entityClass, true);
605    }
606
607    public <Q extends QueryWrapper> Joiner<Q> join(Class<?> entityClass, boolean when) {
608        return joining(SqlConsts.JOIN, entityClass, when);
609    }
610
611    public <Q extends QueryWrapper> Joiner<Q> join(QueryWrapper table) {
612        return joining(SqlConsts.JOIN, table, true);
613    }
614
615    public <Q extends QueryWrapper> Joiner<Q> join(QueryWrapper table, boolean when) {
616        return joining(SqlConsts.JOIN, table, when);
617    }
618
619    public QueryWrapper union(QueryWrapper unionQuery) {
620        if (unions == null) {
621            unions = new ArrayList<>();
622        }
623        unions.add(UnionWrapper.union(unionQuery));
624        return this;
625    }
626
627    public QueryWrapper unionAll(QueryWrapper unionQuery) {
628        if (unions == null) {
629            unions = new ArrayList<>();
630        }
631        unions.add(UnionWrapper.unionAll(unionQuery));
632        return this;
633    }
634
635    public QueryWrapper forUpdate() {
636        addEndFragment("FOR UPDATE");
637        return this;
638    }
639
640    public QueryWrapper forUpdateNoWait() {
641        addEndFragment("FOR UPDATE NOWAIT");
642        return this;
643    }
644
645    //    public QueryWrapper end(String sqlPart){
646    //        addEndFragment(sqlPart);
647    //        return this;
648    //    }
649
650    @SuppressWarnings("unchecked")
651    protected <T extends QueryWrapper> Joiner<T> joining(String type, QueryTable table, boolean when) {
652        Join join = new Join(type, table, when);
653        addJoinTable(join.getQueryTable());
654        return new Joiner<>((T) addJoin(join), join);
655    }
656
657    protected <T extends QueryWrapper> Joiner<T> joining(String type, Class<?> entityClass, boolean when) {
658        TableInfo tableInfo = TableInfoFactory.ofEntityClass(entityClass);
659        QueryTable queryTable = new QueryTable(tableInfo.getSchema(), tableInfo.getTableName());
660        return joining(type, queryTable, when);
661    }
662
663    @SuppressWarnings("unchecked")
664    protected <T extends QueryWrapper> Joiner<T> joining(String type, QueryWrapper queryWrapper, boolean when) {
665        Join join = new Join(type, queryWrapper, when);
666        addJoinTable(join.getQueryTable());
667        return new Joiner<>((T) addJoin(join), join);
668    }
669
670    public QueryWrapper groupBy(String name) {
671        addGroupByColumns(new RawQueryColumn(name));
672        return this;
673    }
674
675    public QueryWrapper groupBy(String... names) {
676        for (String name : names) {
677            groupBy(name);
678        }
679        return this;
680    }
681
682    public QueryWrapper groupBy(QueryColumn column) {
683        addGroupByColumns(column);
684        return this;
685    }
686
687    public QueryWrapper groupBy(QueryColumn... columns) {
688        for (QueryColumn column : columns) {
689            groupBy(column);
690        }
691        return this;
692    }
693
694    public <T> QueryWrapper groupBy(LambdaGetter<T> column) {
695        addGroupByColumns(LambdaUtil.getQueryColumn(column));
696        return this;
697    }
698
699    public <T> QueryWrapper groupBy(LambdaGetter<T>... columns) {
700        for (LambdaGetter<T> column : columns) {
701            groupBy(LambdaUtil.getQueryColumn(column));
702        }
703        return this;
704    }
705
706    public QueryWrapper having(QueryCondition queryCondition) {
707        addHavingQueryCondition(queryCondition, SqlConnector.AND);
708        return this;
709    }
710
711    /**
712     * <p>动态排序。
713     *
714     * <p>排序规则：
715     * <ul>
716     *     <li>{@code null} 不排序
717     *     <li>{@code true} 升序
718     *     <li>{@code false} 降序
719     * </ul>
720     *
721     * @param column 列
722     * @param asc    是否升序
723     * @return {@link QueryWrapper}
724     */
725    public QueryWrapper orderBy(QueryColumn column, Boolean asc) {
726        if (asc != null) {
727            if (asc) {
728                addOrderBy(column.asc());
729            } else {
730                addOrderBy(column.desc());
731            }
732        }
733        return this;
734    }
735
736    public QueryWrapper orderBy(QueryOrderBy... orderBys) {
737        for (QueryOrderBy queryOrderBy : orderBys) {
738            addOrderBy(queryOrderBy);
739        }
740        return this;
741    }
742
743    /**
744     * <p>动态排序。
745     *
746     * <p>排序规则：
747     * <ul>
748     *     <li>{@code null} 不排序
749     *     <li>{@code true} 升序
750     *     <li>{@code false} 降序
751     * </ul>
752     *
753     * @param column 列
754     * @param asc    是否升序
755     * @return {@link QueryWrapper}
756     */
757    public <T> QueryWrapper orderBy(LambdaGetter<T> column, Boolean asc) {
758        if (asc != null) {
759            if (asc) {
760                addOrderBy(LambdaUtil.getQueryColumn(column).asc());
761            } else {
762                addOrderBy(LambdaUtil.getQueryColumn(column).desc());
763            }
764        }
765        return this;
766    }
767
768
769    public <T> QueryOrderByBuilder<? extends QueryWrapper> orderBy(LambdaGetter<T> getter) {
770        return new QueryOrderByBuilder<>(this, getter);
771    }
772
773    /**
774     * <p>动态排序。
775     *
776     * <p>排序规则：
777     * <ul>
778     *     <li>{@code null} 不排序
779     *     <li>{@code true} 升序
780     *     <li>{@code false} 降序
781     * </ul>
782     *
783     * @param column 列
784     * @param asc    是否升序
785     * @return {@link QueryWrapper}
786     */
787    public QueryWrapper orderBy(String column, Boolean asc) {
788        if (asc != null) {
789            if (asc) {
790                addOrderBy(new RawQueryColumn(column).asc());
791            } else {
792                addOrderBy(new RawQueryColumn(column).desc());
793            }
794        }
795        return this;
796    }
797
798    public QueryWrapper orderBy(String... orderBys) {
799        if (orderBys == null || orderBys[0] == null) {
800            // ignore
801            return this;
802        }
803        for (String queryOrderBy : orderBys) {
804            if (StringUtil.isNotBlank(queryOrderBy)) {
805                addOrderBy(new RawQueryOrderBy(queryOrderBy));
806            }
807        }
808        return this;
809    }
810
811    public QueryWrapper orderByUnSafely(String... rawOrderBy) {
812        if (rawOrderBy == null || rawOrderBy[0] == null) {
813            return this;
814        }
815        for (String queryOrderBy : rawOrderBy) {
816            if (StringUtil.isNotBlank(queryOrderBy)) {
817                addOrderBy(new RawQueryOrderBy(queryOrderBy, false));
818            }
819        }
820        return this;
821    }
822
823
824    public QueryWrapper limit(Number rows) {
825        if (rows != null) {
826            setLimitRows(rows.longValue());
827        } else {
828            setLimitRows(null);
829        }
830        return this;
831    }
832
833    public QueryWrapper offset(Number offset) {
834        if (offset != null) {
835            setLimitOffset(offset.longValue());
836        } else {
837            setLimitOffset(null);
838        }
839        return this;
840    }
841
842    public QueryWrapper limit(Number offset, Number rows) {
843        offset(offset);
844        limit(rows);
845        return this;
846    }
847
848    public QueryWrapper datasource(String datasource) {
849        setDataSource(datasource);
850        return this;
851    }
852
853    public QueryWrapper hint(String hint) {
854        setHint(hint);
855        return this;
856    }
857
858
859    /////////MyBatis-Plus 兼容方法///////////////
860
861    /**
862     * 等于 {@code =}
863     *
864     * @param column 列名
865     * @param value  条件的值
866     */
867    public QueryWrapper eq(String column, Object value) {
868        and(QueryMethods.column(column).eq(value));
869        return this;
870    }
871
872    /**
873     * 等于 {@code =}
874     *
875     * @param column 列名, lambda 展示
876     * @param value  值
877     */
878    public <T> QueryWrapper eq(LambdaGetter<T> column, Object value) {
879        and(QueryMethods.column(column).eq(value));
880        return this;
881    }
882
883    /**
884     * 等于 {@code =}
885     *
886     * @param column      列名
887     * @param value       条件的值
888     * @param isEffective 是否有效
889     */
890    public QueryWrapper eq(String column, Object value, boolean isEffective) {
891        and(QueryMethods.column(column).eq(value).when(isEffective));
892        return this;
893    }
894
895    /**
896     * 等于 {@code =}
897     *
898     * @param column      列名, lambda 展示
899     * @param value       值
900     * @param isEffective 是否有效
901     */
902    public <T> QueryWrapper eq(LambdaGetter<T> column, Object value, boolean isEffective) {
903        and(QueryMethods.column(column).eq(value).when(isEffective));
904        return this;
905    }
906
907    /**
908     * 等于 {@code =}
909     *
910     * @param column      列名
911     * @param value       条件的值
912     * @param isEffective 是否有效
913     */
914    public <V> QueryWrapper eq(String column, V value, Predicate<V> isEffective) {
915        and(QueryMethods.column(column).eq(value, isEffective));
916        return this;
917    }
918
919    /**
920     * 等于 {@code =}
921     *
922     * @param column      列名, lambda 展示
923     * @param value       值
924     * @param isEffective 是否有效
925     */
926    public <T, V> QueryWrapper eq(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
927        and(QueryMethods.column(column).eq(value, isEffective));
928        return this;
929    }
930
931
932    /**
933     * 不等于 {@code !=}
934     *
935     * @param column 列名
936     * @param value  条件的值
937     */
938    public QueryWrapper ne(String column, Object value) {
939        and(QueryMethods.column(column).ne(value));
940        return this;
941    }
942
943    /**
944     * 不等于 {@code !=}
945     *
946     * @param column 列名, lambda 展示
947     * @param value  值
948     */
949    public <T> QueryWrapper ne(LambdaGetter<T> column, Object value) {
950        and(QueryMethods.column(column).ne(value));
951        return this;
952    }
953
954    /**
955     * 不等于 {@code !=}
956     *
957     * @param column      列名
958     * @param value       条件的值
959     * @param isEffective 是否有效
960     */
961    public QueryWrapper ne(String column, Object value, boolean isEffective) {
962        and(QueryMethods.column(column).ne(value).when(isEffective));
963        return this;
964    }
965
966    /**
967     * 不等于 {@code !=}
968     *
969     * @param column      列名, lambda 展示
970     * @param value       值
971     * @param isEffective 是否有效
972     */
973    public <T> QueryWrapper ne(LambdaGetter<T> column, Object value, boolean isEffective) {
974        and(QueryMethods.column(column).ne(value).when(isEffective));
975        return this;
976    }
977
978    /**
979     * 不等于 {@code !=}
980     *
981     * @param column      列名
982     * @param value       条件的值
983     * @param isEffective 是否有效
984     */
985    public <V> QueryWrapper ne(String column, V value, Predicate<V> isEffective) {
986        and(QueryMethods.column(column).ne(value, isEffective));
987        return this;
988    }
989
990    /**
991     * 不等于 {@code !=}
992     *
993     * @param column      列名, lambda 展示
994     * @param value       值
995     * @param isEffective 是否有效
996     */
997    public <T, V> QueryWrapper ne(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
998        and(QueryMethods.column(column).ne(value, isEffective));
999        return this;
1000    }
1001
1002
1003    /**
1004     * 大于 {@code >}
1005     *
1006     * @param column 列名
1007     * @param value  条件的值
1008     */
1009    public QueryWrapper gt(String column, Object value) {
1010        and(QueryMethods.column(column).gt(value));
1011        return this;
1012    }
1013
1014    /**
1015     * 大于 {@code >}
1016     *
1017     * @param column 列名, lambda 展示
1018     * @param value  值
1019     */
1020    public <T> QueryWrapper gt(LambdaGetter<T> column, Object value) {
1021        and(QueryMethods.column(column).gt(value));
1022        return this;
1023    }
1024
1025    /**
1026     * 大于 {@code >}
1027     *
1028     * @param column      列名
1029     * @param value       条件的值
1030     * @param isEffective 是否有效
1031     */
1032    public QueryWrapper gt(String column, Object value, boolean isEffective) {
1033        and(QueryMethods.column(column).gt(value).when(isEffective));
1034        return this;
1035    }
1036
1037    /**
1038     * 大于 {@code >}
1039     *
1040     * @param column      列名, lambda 展示
1041     * @param value       值
1042     * @param isEffective 是否有效
1043     */
1044    public <T> QueryWrapper gt(LambdaGetter<T> column, Object value, boolean isEffective) {
1045        and(QueryMethods.column(column).gt(value).when(isEffective));
1046        return this;
1047    }
1048
1049    /**
1050     * 大于 {@code >}
1051     *
1052     * @param column      列名
1053     * @param value       条件的值
1054     * @param isEffective 是否有效
1055     */
1056    public <V> QueryWrapper gt(String column, V value, Predicate<V> isEffective) {
1057        and(QueryMethods.column(column).gt(value, isEffective));
1058        return this;
1059    }
1060
1061    /**
1062     * 大于 {@code >}
1063     *
1064     * @param column      列名, lambda 展示
1065     * @param value       值
1066     * @param isEffective 是否有效
1067     */
1068    public <T, V> QueryWrapper gt(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1069        and(QueryMethods.column(column).gt(value, isEffective));
1070        return this;
1071    }
1072
1073
1074    /**
1075     * 大于等于 {@code >=}
1076     *
1077     * @param column 列名
1078     * @param value  条件的值
1079     */
1080    public QueryWrapper ge(String column, Object value) {
1081        and(QueryMethods.column(column).ge(value));
1082        return this;
1083    }
1084
1085    /**
1086     * 大于等于 {@code >=}
1087     *
1088     * @param column 列名, lambda 展示
1089     * @param value  值
1090     */
1091    public <T> QueryWrapper ge(LambdaGetter<T> column, Object value) {
1092        and(QueryMethods.column(column).ge(value));
1093        return this;
1094    }
1095
1096    /**
1097     * 大于等于 {@code >=}
1098     *
1099     * @param column      列名
1100     * @param value       条件的值
1101     * @param isEffective 是否有效
1102     */
1103    public QueryWrapper ge(String column, Object value, boolean isEffective) {
1104        and(QueryMethods.column(column).ge(value).when(isEffective));
1105        return this;
1106    }
1107
1108    /**
1109     * 大于等于 {@code >=}
1110     *
1111     * @param column      列名, lambda 展示
1112     * @param value       值
1113     * @param isEffective 是否有效
1114     */
1115    public <T> QueryWrapper ge(LambdaGetter<T> column, Object value, boolean isEffective) {
1116        and(QueryMethods.column(column).ge(value).when(isEffective));
1117        return this;
1118    }
1119
1120    /**
1121     * 大于等于 {@code >=}
1122     *
1123     * @param column      列名
1124     * @param value       条件的值
1125     * @param isEffective 是否有效
1126     */
1127    public <V> QueryWrapper ge(String column, V value, Predicate<V> isEffective) {
1128        and(QueryMethods.column(column).ge(value, isEffective));
1129        return this;
1130    }
1131
1132    /**
1133     * 大于等于 {@code >=}
1134     *
1135     * @param column      列名, lambda 展示
1136     * @param value       值
1137     * @param isEffective 是否有效
1138     */
1139    public <T, V> QueryWrapper ge(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1140        and(QueryMethods.column(column).ge(value, isEffective));
1141        return this;
1142    }
1143
1144
1145    /**
1146     * 小于 {@code <}
1147     *
1148     * @param column 列名
1149     * @param value  条件的值
1150     */
1151    public QueryWrapper lt(String column, Object value) {
1152        and(QueryMethods.column(column).lt(value));
1153        return this;
1154    }
1155
1156    /**
1157     * 小于 {@code <}
1158     *
1159     * @param column 列名, lambda 展示
1160     * @param value  值
1161     */
1162    public <T> QueryWrapper lt(LambdaGetter<T> column, Object value) {
1163        and(QueryMethods.column(column).lt(value));
1164        return this;
1165    }
1166
1167    /**
1168     * 小于 {@code <}
1169     *
1170     * @param column      列名
1171     * @param value       条件的值
1172     * @param isEffective 是否有效
1173     */
1174    public QueryWrapper lt(String column, Object value, boolean isEffective) {
1175        and(QueryMethods.column(column).lt(value).when(isEffective));
1176        return this;
1177    }
1178
1179    /**
1180     * 小于 {@code <}
1181     *
1182     * @param column      列名, lambda 展示
1183     * @param value       值
1184     * @param isEffective 是否有效
1185     */
1186    public <T> QueryWrapper lt(LambdaGetter<T> column, Object value, boolean isEffective) {
1187        and(QueryMethods.column(column).lt(value).when(isEffective));
1188        return this;
1189    }
1190
1191    /**
1192     * 小于 {@code <}
1193     *
1194     * @param column      列名
1195     * @param value       条件的值
1196     * @param isEffective 是否有效
1197     */
1198    public <V> QueryWrapper lt(String column, V value, Predicate<V> isEffective) {
1199        and(QueryMethods.column(column).lt(value, isEffective));
1200        return this;
1201    }
1202
1203    /**
1204     * 小于 {@code <}
1205     *
1206     * @param column      列名, lambda 展示
1207     * @param value       值
1208     * @param isEffective 是否有效
1209     */
1210    public <T, V> QueryWrapper lt(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1211        and(QueryMethods.column(column).lt(value, isEffective));
1212        return this;
1213    }
1214
1215
1216    /**
1217     * 小于等于 {@code <=}
1218     *
1219     * @param column 列名
1220     * @param value  条件的值
1221     */
1222    public QueryWrapper le(String column, Object value) {
1223        and(QueryMethods.column(column).le(value));
1224        return this;
1225    }
1226
1227    /**
1228     * 小于等于 {@code <=}
1229     *
1230     * @param column 列名, lambda 展示
1231     * @param value  值
1232     */
1233    public <T> QueryWrapper le(LambdaGetter<T> column, Object value) {
1234        and(QueryMethods.column(column).le(value));
1235        return this;
1236    }
1237
1238    /**
1239     * 小于等于 {@code <=}
1240     *
1241     * @param column      列名
1242     * @param value       条件的值
1243     * @param isEffective 是否有效
1244     */
1245    public QueryWrapper le(String column, Object value, boolean isEffective) {
1246        and(QueryMethods.column(column).le(value).when(isEffective));
1247        return this;
1248    }
1249
1250    /**
1251     * 小于等于 {@code <=}
1252     *
1253     * @param column      列名, lambda 展示
1254     * @param value       值
1255     * @param isEffective 是否有效
1256     */
1257    public <T> QueryWrapper le(LambdaGetter<T> column, Object value, boolean isEffective) {
1258        and(QueryMethods.column(column).le(value).when(isEffective));
1259        return this;
1260    }
1261
1262    /**
1263     * 小于等于 {@code <=}
1264     *
1265     * @param column      列名
1266     * @param value       条件的值
1267     * @param isEffective 是否有效
1268     */
1269    public <V> QueryWrapper le(String column, V value, Predicate<V> isEffective) {
1270        and(QueryMethods.column(column).le(value, isEffective));
1271        return this;
1272    }
1273
1274    /**
1275     * 小于等于 {@code <=}
1276     *
1277     * @param column      列名, lambda 展示
1278     * @param value       值
1279     * @param isEffective 是否有效
1280     */
1281    public <T, V> QueryWrapper le(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1282        and(QueryMethods.column(column).le(value, isEffective));
1283        return this;
1284    }
1285
1286
1287    /**
1288     * {@code IN(value)}
1289     *
1290     * @param column 列名
1291     * @param values 条件的值
1292     */
1293    public QueryWrapper in(String column, Object... values) {
1294        and(QueryMethods.column(column).in(values));
1295        return this;
1296    }
1297
1298    /**
1299     * {@code IN(value)}
1300     *
1301     * @param column 列名, lambda 展示
1302     * @param values 值
1303     */
1304    public <T> QueryWrapper in(LambdaGetter<T> column, Object... values) {
1305        and(QueryMethods.column(column).in(values));
1306        return this;
1307    }
1308
1309
1310    /**
1311     * {@code IN(value)}
1312     *
1313     * @param column       列名
1314     * @param queryWrapper 条件的值
1315     */
1316    public QueryWrapper in(String column, QueryWrapper queryWrapper) {
1317        and(QueryMethods.column(column).in(queryWrapper));
1318        return this;
1319    }
1320
1321
1322    /**
1323     * {@code IN(value)}
1324     *
1325     * @param column       列名, lambda 展示
1326     * @param queryWrapper 值
1327     */
1328    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper) {
1329        and(QueryMethods.column(column).in(queryWrapper));
1330        return this;
1331    }
1332
1333
1334    /**
1335     * {@code IN(value)}
1336     *
1337     * @param column 列名
1338     * @param values 条件的值
1339     */
1340    public QueryWrapper in(String column, Collection<?> values) {
1341        and(QueryMethods.column(column).in(values));
1342        return this;
1343    }
1344
1345    /**
1346     * {@code IN(value)}
1347     *
1348     * @param column 列名, lambda 展示
1349     * @param values 值
1350     */
1351    public <T> QueryWrapper in(LambdaGetter<T> column, Collection<?> values) {
1352        and(QueryMethods.column(column).in(values));
1353        return this;
1354    }
1355
1356
1357    /**
1358     * {@code IN(value)}
1359     *
1360     * @param column 列名
1361     * @param values 条件的值
1362     */
1363    public QueryWrapper in(String column, Object[] values, boolean isEffective) {
1364        and(QueryMethods.column(column).in(values, isEffective));
1365        return this;
1366    }
1367
1368    /**
1369     * {@code IN(value)}
1370     *
1371     * @param column 列名, lambda 展示
1372     * @param values 值
1373     */
1374    public <T> QueryWrapper in(LambdaGetter<T> column, Object[] values, boolean isEffective) {
1375        and(QueryMethods.column(column).in(values, isEffective));
1376        return this;
1377    }
1378
1379
1380    /**
1381     * {@code IN(value)}
1382     *
1383     * @param column 列名
1384     * @param values 条件的值
1385     */
1386    public QueryWrapper in(String column, Collection<?> values, boolean isEffective) {
1387        and(QueryMethods.column(column).in(values, isEffective));
1388        return this;
1389    }
1390
1391    /**
1392     * {@code IN(value)}
1393     *
1394     * @param column 列名, lambda 展示
1395     * @param values 值
1396     */
1397    public <T> QueryWrapper in(LambdaGetter<T> column, Collection<?> values, boolean isEffective) {
1398        and(QueryMethods.column(column).in(values, isEffective));
1399        return this;
1400    }
1401
1402
1403    /**
1404     * {@code IN(value)}
1405     *
1406     * @param column       列名
1407     * @param queryWrapper 条件的值
1408     */
1409    public QueryWrapper in(String column, QueryWrapper queryWrapper, boolean isEffective) {
1410        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1411        return this;
1412    }
1413
1414
1415    /**
1416     * {@code IN(value)}
1417     *
1418     * @param column       列名, lambda 展示
1419     * @param queryWrapper 值
1420     */
1421    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper, boolean isEffective) {
1422        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1423        return this;
1424    }
1425
1426
1427    /**
1428     * {@code IN(value)}
1429     *
1430     * @param column       列名
1431     * @param queryWrapper 条件的值
1432     */
1433    public QueryWrapper in(String column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1434        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1435        return this;
1436    }
1437
1438
1439    /**
1440     * {@code IN(value)}
1441     *
1442     * @param column       列名, lambda 展示
1443     * @param queryWrapper 值
1444     */
1445    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1446        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1447        return this;
1448    }
1449
1450
1451    /**
1452     * {@code NOT IN(value)}
1453     *
1454     * @param column 列名
1455     * @param values 条件的值
1456     */
1457    public QueryWrapper notIn(String column, Object... values) {
1458        and(QueryMethods.column(column).notIn(values));
1459        return this;
1460    }
1461
1462    /**
1463     * {@code NOT IN(value)}
1464     *
1465     * @param column 列名, lambda 展示
1466     * @param values 值
1467     */
1468    public <T> QueryWrapper notIn(LambdaGetter<T> column, Object... values) {
1469        and(QueryMethods.column(column).notIn(values));
1470        return this;
1471    }
1472
1473
1474    /**
1475     * {@code NOT IN(value)}
1476     *
1477     * @param column       列名
1478     * @param queryWrapper 条件的值
1479     */
1480    public QueryWrapper notIn(String column, QueryWrapper queryWrapper) {
1481        and(QueryMethods.column(column).notIn(queryWrapper));
1482        return this;
1483    }
1484
1485
1486    /**
1487     * {@code NOT IN(value)}
1488     *
1489     * @param column       列名, lambda 展示
1490     * @param queryWrapper 值
1491     */
1492    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper) {
1493        and(QueryMethods.column(column).notIn(queryWrapper));
1494        return this;
1495    }
1496
1497
1498    /**
1499     * {@code NOT IN(value)}
1500     *
1501     * @param column 列名
1502     * @param values 条件的值
1503     */
1504    public QueryWrapper notIn(String column, Collection<?> values) {
1505        and(QueryMethods.column(column).notIn(values));
1506        return this;
1507    }
1508
1509    /**
1510     * {@code NOT IN(value)}
1511     *
1512     * @param column 列名, lambda 展示
1513     * @param values 值
1514     */
1515    public <T> QueryWrapper notIn(LambdaGetter<T> column, Collection<?> values) {
1516        and(QueryMethods.column(column).notIn(values));
1517        return this;
1518    }
1519
1520
1521    /**
1522     * {@code NOT IN(value)}
1523     *
1524     * @param column 列名
1525     * @param values 条件的值
1526     */
1527    public QueryWrapper notIn(String column, Object[] values, boolean isEffective) {
1528        and(QueryMethods.column(column).notIn(values, isEffective));
1529        return this;
1530    }
1531
1532    /**
1533     * {@code NOT IN(value)}
1534     *
1535     * @param column 列名, lambda 展示
1536     * @param values 值
1537     */
1538    public <T> QueryWrapper notIn(LambdaGetter<T> column, Object[] values, boolean isEffective) {
1539        and(QueryMethods.column(column).notIn(values, isEffective));
1540        return this;
1541    }
1542
1543
1544    /**
1545     * {@code NOT IN(value)}
1546     *
1547     * @param column 列名
1548     * @param values 条件的值
1549     */
1550    public QueryWrapper notIn(String column, Collection<?> values, boolean isEffective) {
1551        and(QueryMethods.column(column).notIn(values, isEffective));
1552        return this;
1553    }
1554
1555    /**
1556     * {@code NOT IN(value)}
1557     *
1558     * @param column 列名, lambda 展示
1559     * @param values 值
1560     */
1561    public <T> QueryWrapper notIn(LambdaGetter<T> column, Collection<?> values, boolean isEffective) {
1562        and(QueryMethods.column(column).notIn(values, isEffective));
1563        return this;
1564    }
1565
1566
1567    /**
1568     * {@code NOT IN(value)}
1569     *
1570     * @param column       列名
1571     * @param queryWrapper 条件的值
1572     */
1573    public QueryWrapper notIn(String column, QueryWrapper queryWrapper, boolean isEffective) {
1574        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1575        return this;
1576    }
1577
1578
1579    /**
1580     * {@code NOT IN(value)}
1581     *
1582     * @param column       列名, lambda 展示
1583     * @param queryWrapper 值
1584     */
1585    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper, boolean isEffective) {
1586        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1587        return this;
1588    }
1589
1590
1591    /**
1592     * {@code NOT IN(value)}
1593     *
1594     * @param column       列名
1595     * @param queryWrapper 条件的值
1596     */
1597    public QueryWrapper notIn(String column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1598        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1599        return this;
1600    }
1601
1602
1603    /**
1604     * {@code NOT IN(value)}
1605     *
1606     * @param column       列名, lambda 展示
1607     * @param queryWrapper 值
1608     */
1609    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1610        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1611        return this;
1612    }
1613
1614
1615    /**
1616     * {@code BETWEEN start AND end}
1617     *
1618     * @param column 列名
1619     * @param start  开始的值
1620     * @param end    结束的值
1621     */
1622    public QueryWrapper between(String column, Object start, Object end) {
1623        and(QueryMethods.column(column).between(start, end));
1624        return this;
1625    }
1626
1627    /**
1628     * {@code BETWEEN start AND end}
1629     *
1630     * @param column 列名
1631     * @param start  开始的值
1632     * @param end    结束的值
1633     */
1634    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end) {
1635        and(QueryMethods.column(column).between(start, end));
1636        return this;
1637    }
1638
1639    /**
1640     * {@code BETWEEN start AND end}
1641     *
1642     * @param column 列名
1643     * @param start  开始的值
1644     * @param end    结束的值
1645     */
1646    public QueryWrapper between(String column, Object start, Object end, boolean isEffective) {
1647        and(QueryMethods.column(column).between(start, end, isEffective));
1648        return this;
1649    }
1650
1651    /**
1652     * {@code BETWEEN start AND end}
1653     *
1654     * @param column 列名
1655     * @param start  开始的值
1656     * @param end    结束的值
1657     */
1658    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end, boolean isEffective) {
1659        and(QueryMethods.column(column).between(start, end, isEffective));
1660        return this;
1661    }
1662
1663
1664    /**
1665     * {@code BETWEEN start AND end}
1666     *
1667     * @param column 列名
1668     * @param start  开始的值
1669     * @param end    结束的值
1670     */
1671    public QueryWrapper between(String column, Object start, Object end, BooleanSupplier isEffective) {
1672        and(QueryMethods.column(column).between(start, end, isEffective));
1673        return this;
1674    }
1675
1676    /**
1677     * {@code BETWEEN start AND end}
1678     *
1679     * @param column 列名
1680     * @param start  开始的值
1681     * @param end    结束的值
1682     */
1683    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end, BooleanSupplier isEffective) {
1684        and(QueryMethods.column(column).between(start, end, isEffective));
1685        return this;
1686    }
1687
1688
1689    /**
1690     * {@code NOT BETWEEN start AND end}
1691     *
1692     * @param column 列名
1693     * @param start  开始的值
1694     * @param end    结束的值
1695     */
1696    public QueryWrapper notBetween(String column, Object start, Object end) {
1697        and(QueryMethods.column(column).notBetween(start, end));
1698        return this;
1699    }
1700
1701    /**
1702     * {@code NOT BETWEEN start AND end}
1703     *
1704     * @param column 列名
1705     * @param start  开始的值
1706     * @param end    结束的值
1707     */
1708    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end) {
1709        and(QueryMethods.column(column).notBetween(start, end));
1710        return this;
1711    }
1712
1713    /**
1714     * {@code NOT BETWEEN start AND end}
1715     *
1716     * @param column 列名
1717     * @param start  开始的值
1718     * @param end    结束的值
1719     */
1720    public QueryWrapper notBetween(String column, Object start, Object end, boolean isEffective) {
1721        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1722        return this;
1723    }
1724
1725    /**
1726     * {@code NOT BETWEEN start AND end}
1727     *
1728     * @param column 列名
1729     * @param start  开始的值
1730     * @param end    结束的值
1731     */
1732    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end, boolean isEffective) {
1733        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1734        return this;
1735    }
1736
1737
1738    /**
1739     * {@code NOT BETWEEN start AND end}
1740     *
1741     * @param column 列名
1742     * @param start  开始的值
1743     * @param end    结束的值
1744     */
1745    public QueryWrapper notBetween(String column, Object start, Object end, BooleanSupplier isEffective) {
1746        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1747        return this;
1748    }
1749
1750    /**
1751     * {@code NOT BETWEEN start AND end}
1752     *
1753     * @param column 列名
1754     * @param start  开始的值
1755     * @param end    结束的值
1756     */
1757    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end, BooleanSupplier isEffective) {
1758        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1759        return this;
1760    }
1761
1762
1763    /**
1764     * {@code LIKE %value%}
1765     *
1766     * @param column 列名
1767     * @param value  条件的值
1768     */
1769    public QueryWrapper like(String column, Object value) {
1770        and(QueryMethods.column(column).like(value));
1771        return this;
1772    }
1773
1774    /**
1775     * {@code LIKE %value%}
1776     *
1777     * @param column 列名, lambda 展示
1778     * @param value  值
1779     */
1780    public <T> QueryWrapper like(LambdaGetter<T> column, Object value) {
1781        and(QueryMethods.column(column).like(value));
1782        return this;
1783    }
1784
1785    /**
1786     * {@code LIKE %value%}
1787     *
1788     * @param column      列名
1789     * @param value       条件的值
1790     * @param isEffective 是否有效
1791     */
1792    public QueryWrapper like(String column, Object value, boolean isEffective) {
1793        and(QueryMethods.column(column).like(value).when(isEffective));
1794        return this;
1795    }
1796
1797    /**
1798     * {@code LIKE %value%}
1799     *
1800     * @param column      列名, lambda 展示
1801     * @param value       值
1802     * @param isEffective 是否有效
1803     */
1804    public <T> QueryWrapper like(LambdaGetter<T> column, Object value, boolean isEffective) {
1805        and(QueryMethods.column(column).like(value).when(isEffective));
1806        return this;
1807    }
1808
1809    /**
1810     * {@code LIKE %value%}
1811     *
1812     * @param column      列名
1813     * @param value       条件的值
1814     * @param isEffective 是否有效
1815     */
1816    public <V> QueryWrapper like(String column, V value, Predicate<V> isEffective) {
1817        and(QueryMethods.column(column).like(value, isEffective));
1818        return this;
1819    }
1820
1821    /**
1822     * {@code LIKE %value%}
1823     *
1824     * @param column      列名, lambda 展示
1825     * @param value       值
1826     * @param isEffective 是否有效
1827     */
1828    public <T, V> QueryWrapper like(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1829        and(QueryMethods.column(column).like(value, isEffective));
1830        return this;
1831    }
1832
1833
1834    /**
1835     * {@code LIKE value%}
1836     *
1837     * @param column 列名
1838     * @param value  条件的值
1839     */
1840    public QueryWrapper likeLeft(String column, Object value) {
1841        and(QueryMethods.column(column).likeLeft(value));
1842        return this;
1843    }
1844
1845    /**
1846     * {@code LIKE value%}
1847     *
1848     * @param column 列名, lambda 展示
1849     * @param value  值
1850     */
1851    public <T> QueryWrapper likeLeft(LambdaGetter<T> column, Object value) {
1852        and(QueryMethods.column(column).likeLeft(value));
1853        return this;
1854    }
1855
1856    /**
1857     * {@code LIKE value%}
1858     *
1859     * @param column      列名
1860     * @param value       条件的值
1861     * @param isEffective 是否有效
1862     */
1863    public QueryWrapper likeLeft(String column, Object value, boolean isEffective) {
1864        and(QueryMethods.column(column).likeLeft(value).when(isEffective));
1865        return this;
1866    }
1867
1868    /**
1869     * {@code LIKE value%}
1870     *
1871     * @param column      列名, lambda 展示
1872     * @param value       值
1873     * @param isEffective 是否有效
1874     */
1875    public <T> QueryWrapper likeLeft(LambdaGetter<T> column, Object value, boolean isEffective) {
1876        and(QueryMethods.column(column).likeLeft(value).when(isEffective));
1877        return this;
1878    }
1879
1880    /**
1881     * {@code LIKE value%}
1882     *
1883     * @param column      列名
1884     * @param value       条件的值
1885     * @param isEffective 是否有效
1886     */
1887    public <V> QueryWrapper likeLeft(String column, V value, Predicate<V> isEffective) {
1888        and(QueryMethods.column(column).likeLeft(value, isEffective));
1889        return this;
1890    }
1891
1892    /**
1893     * {@code LIKE value%}
1894     *
1895     * @param column      列名, lambda 展示
1896     * @param value       值
1897     * @param isEffective 是否有效
1898     */
1899    public <T, V> QueryWrapper likeLeft(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1900        and(QueryMethods.column(column).likeLeft(value, isEffective));
1901        return this;
1902    }
1903
1904
1905    /**
1906     * {@code LIKE %value}
1907     *
1908     * @param column 列名
1909     * @param value  条件的值
1910     */
1911    public QueryWrapper likeRight(String column, Object value) {
1912        and(QueryMethods.column(column).likeRight(value));
1913        return this;
1914    }
1915
1916    /**
1917     * {@code LIKE %value}
1918     *
1919     * @param column 列名, lambda 展示
1920     * @param value  值
1921     */
1922    public <T> QueryWrapper likeRight(LambdaGetter<T> column, Object value) {
1923        and(QueryMethods.column(column).likeRight(value));
1924        return this;
1925    }
1926
1927    /**
1928     * {@code LIKE %value}
1929     *
1930     * @param column      列名
1931     * @param value       条件的值
1932     * @param isEffective 是否有效
1933     */
1934    public QueryWrapper likeRight(String column, Object value, boolean isEffective) {
1935        and(QueryMethods.column(column).likeRight(value).when(isEffective));
1936        return this;
1937    }
1938
1939    /**
1940     * {@code LIKE %value}
1941     *
1942     * @param column      列名, lambda 展示
1943     * @param value       值
1944     * @param isEffective 是否有效
1945     */
1946    public <T> QueryWrapper likeRight(LambdaGetter<T> column, Object value, boolean isEffective) {
1947        and(QueryMethods.column(column).likeRight(value).when(isEffective));
1948        return this;
1949    }
1950
1951    /**
1952     * {@code LIKE %value}
1953     *
1954     * @param column      列名
1955     * @param value       条件的值
1956     * @param isEffective 是否有效
1957     */
1958    public <V> QueryWrapper likeRight(String column, V value, Predicate<V> isEffective) {
1959        and(QueryMethods.column(column).likeRight(value, isEffective));
1960        return this;
1961    }
1962
1963    /**
1964     * {@code LIKE %value}
1965     *
1966     * @param column      列名, lambda 展示
1967     * @param value       值
1968     * @param isEffective 是否有效
1969     */
1970    public <T, V> QueryWrapper likeRight(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1971        and(QueryMethods.column(column).likeRight(value, isEffective));
1972        return this;
1973    }
1974
1975
1976    /**
1977     * {@code NOT LIKE %value%}
1978     *
1979     * @param column 列名
1980     * @param value  条件的值
1981     */
1982    public QueryWrapper notLike(String column, Object value) {
1983        and(QueryMethods.column(column).notLike(value));
1984        return this;
1985    }
1986
1987    /**
1988     * {@code NOT LIKE %value%}
1989     *
1990     * @param column 列名, lambda 展示
1991     * @param value  值
1992     */
1993    public <T> QueryWrapper notLike(LambdaGetter<T> column, Object value) {
1994        and(QueryMethods.column(column).notLike(value));
1995        return this;
1996    }
1997
1998    /**
1999     * {@code NOT LIKE %value%}
2000     *
2001     * @param column      列名
2002     * @param value       条件的值
2003     * @param isEffective 是否有效
2004     */
2005    public QueryWrapper notLike(String column, Object value, boolean isEffective) {
2006        and(QueryMethods.column(column).notLike(value).when(isEffective));
2007        return this;
2008    }
2009
2010    /**
2011     * {@code NOT LIKE %value%}
2012     *
2013     * @param column      列名, lambda 展示
2014     * @param value       值
2015     * @param isEffective 是否有效
2016     */
2017    public <T> QueryWrapper notLike(LambdaGetter<T> column, Object value, boolean isEffective) {
2018        and(QueryMethods.column(column).notLike(value).when(isEffective));
2019        return this;
2020    }
2021
2022    /**
2023     * {@code NOT LIKE %value%}
2024     *
2025     * @param column      列名
2026     * @param value       条件的值
2027     * @param isEffective 是否有效
2028     */
2029    public <V> QueryWrapper notLike(String column, V value, Predicate<V> isEffective) {
2030        and(QueryMethods.column(column).notLike(value, isEffective));
2031        return this;
2032    }
2033
2034    /**
2035     * {@code NOT LIKE %value%}
2036     *
2037     * @param column      列名, lambda 展示
2038     * @param value       值
2039     * @param isEffective 是否有效
2040     */
2041    public <T, V> QueryWrapper notLike(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
2042        and(QueryMethods.column(column).notLike(value, isEffective));
2043        return this;
2044    }
2045
2046
2047    /**
2048     * {@code NOT LIKE value%}
2049     *
2050     * @param column 列名
2051     * @param value  条件的值
2052     */
2053    public QueryWrapper notLikeLeft(String column, Object value) {
2054        and(QueryMethods.column(column).notLikeLeft(value));
2055        return this;
2056    }
2057
2058    /**
2059     * {@code NOT LIKE value%}
2060     *
2061     * @param column 列名, lambda 展示
2062     * @param value  值
2063     */
2064    public <T> QueryWrapper notLikeLeft(LambdaGetter<T> column, Object value) {
2065        and(QueryMethods.column(column).notLikeLeft(value));
2066        return this;
2067    }
2068
2069    /**
2070     * {@code NOT LIKE value%}
2071     *
2072     * @param column      列名
2073     * @param value       条件的值
2074     * @param isEffective 是否有效
2075     */
2076    public QueryWrapper notLikeLeft(String column, Object value, boolean isEffective) {
2077        and(QueryMethods.column(column).notLikeLeft(value).when(isEffective));
2078        return this;
2079    }
2080
2081    /**
2082     * {@code NOT LIKE value%}
2083     *
2084     * @param column      列名, lambda 展示
2085     * @param value       值
2086     * @param isEffective 是否有效
2087     */
2088    public <T> QueryWrapper notLikeLeft(LambdaGetter<T> column, Object value, boolean isEffective) {
2089        and(QueryMethods.column(column).notLikeLeft(value).when(isEffective));
2090        return this;
2091    }
2092
2093    /**
2094     * {@code NOT LIKE value%}
2095     *
2096     * @param column      列名
2097     * @param value       条件的值
2098     * @param isEffective 是否有效
2099     */
2100    public <V> QueryWrapper notLikeLeft(String column, V value, Predicate<V> isEffective) {
2101        and(QueryMethods.column(column).notLikeLeft(value, isEffective));
2102        return this;
2103    }
2104
2105    /**
2106     * {@code NOT LIKE value%}
2107     *
2108     * @param column      列名, lambda 展示
2109     * @param value       值
2110     * @param isEffective 是否有效
2111     */
2112    public <T, V> QueryWrapper notLikeLeft(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
2113        and(QueryMethods.column(column).notLikeLeft(value, isEffective));
2114        return this;
2115    }
2116
2117
2118    /**
2119     * {@code NOT LIKE %value}
2120     *
2121     * @param column 列名
2122     * @param value  条件的值
2123     */
2124    public QueryWrapper notLikeRight(String column, Object value) {
2125        and(QueryMethods.column(column).notLikeRight(value));
2126        return this;
2127    }
2128
2129    /**
2130     * {@code NOT LIKE %value}
2131     *
2132     * @param column 列名, lambda 展示
2133     * @param value  值
2134     */
2135    public <T> QueryWrapper notLikeRight(LambdaGetter<T> column, Object value) {
2136        and(QueryMethods.column(column).notLikeRight(value));
2137        return this;
2138    }
2139
2140    /**
2141     * {@code NOT LIKE %value}
2142     *
2143     * @param column      列名
2144     * @param value       条件的值
2145     * @param isEffective 是否有效
2146     */
2147    public QueryWrapper notLikeRight(String column, Object value, boolean isEffective) {
2148        and(QueryMethods.column(column).notLikeRight(value).when(isEffective));
2149        return this;
2150    }
2151
2152    /**
2153     * {@code NOT LIKE %value}
2154     *
2155     * @param column      列名, lambda 展示
2156     * @param value       值
2157     * @param isEffective 是否有效
2158     */
2159    public <T> QueryWrapper notLikeRight(LambdaGetter<T> column, Object value, boolean isEffective) {
2160        and(QueryMethods.column(column).notLikeRight(value).when(isEffective));
2161        return this;
2162    }
2163
2164    /**
2165     * {@code NOT LIKE %value}
2166     *
2167     * @param column      列名
2168     * @param value       条件的值
2169     * @param isEffective 是否有效
2170     */
2171    public <V> QueryWrapper notLikeRight(String column, V value, Predicate<V> isEffective) {
2172        and(QueryMethods.column(column).notLikeRight(value, isEffective));
2173        return this;
2174    }
2175
2176    /**
2177     * {@code NOT LIKE %value}
2178     *
2179     * @param column      列名, lambda 展示
2180     * @param value       值
2181     * @param isEffective 是否有效
2182     */
2183    public <T, V> QueryWrapper notLikeRight(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
2184        and(QueryMethods.column(column).notLikeRight(value, isEffective));
2185        return this;
2186    }
2187
2188
2189    /**
2190     * {@code IS NULL}
2191     *
2192     * @param column 列名
2193     */
2194    public QueryWrapper isNull(String column) {
2195        and(QueryMethods.column(column).isNull());
2196        return this;
2197    }
2198
2199    /**
2200     * {@code IS NULL}
2201     *
2202     * @param column 列名, lambda 展示
2203     */
2204    public <T> QueryWrapper isNull(LambdaGetter<T> column) {
2205        and(QueryMethods.column(column).isNull());
2206        return this;
2207    }
2208
2209    /**
2210     * {@code IS NULL}
2211     *
2212     * @param column      列名
2213     * @param isEffective 是否有效
2214     */
2215    public QueryWrapper isNull(String column, boolean isEffective) {
2216        and(QueryMethods.column(column).isNull(isEffective));
2217        return this;
2218    }
2219
2220    /**
2221     * {@code IS NULL}
2222     *
2223     * @param column      列名, lambda 展示
2224     * @param isEffective 是否有效
2225     */
2226    public <T> QueryWrapper isNull(LambdaGetter<T> column, boolean isEffective) {
2227        and(QueryMethods.column(column).isNull(isEffective));
2228        return this;
2229    }
2230
2231    /**
2232     * {@code IS NULL}
2233     *
2234     * @param column      列名
2235     * @param isEffective 是否有效
2236     */
2237    public QueryWrapper isNull(String column, BooleanSupplier isEffective) {
2238        and(QueryMethods.column(column).isNull(isEffective));
2239        return this;
2240    }
2241
2242    /**
2243     * {@code IS NULL}
2244     *
2245     * @param column      列名, lambda 展示
2246     * @param isEffective 是否有效
2247     */
2248    public <T> QueryWrapper isNull(LambdaGetter<T> column, BooleanSupplier isEffective) {
2249        and(QueryMethods.column(column).isNull(isEffective));
2250        return this;
2251    }
2252
2253
2254    /**
2255     * {@code IS NOT NULL}
2256     *
2257     * @param column 列名
2258     */
2259    public QueryWrapper isNotNull(String column) {
2260        and(QueryMethods.column(column).isNotNull());
2261        return this;
2262    }
2263
2264    /**
2265     * {@code IS NOT NULL}
2266     *
2267     * @param column 列名, lambda 展示
2268     */
2269    public <T> QueryWrapper isNotNull(LambdaGetter<T> column) {
2270        and(QueryMethods.column(column).isNotNull());
2271        return this;
2272    }
2273
2274    /**
2275     * {@code IS NOT NULL}
2276     *
2277     * @param column      列名
2278     * @param isEffective 是否有效
2279     */
2280    public QueryWrapper isNotNull(String column, boolean isEffective) {
2281        and(QueryMethods.column(column).isNotNull(isEffective));
2282        return this;
2283    }
2284
2285    /**
2286     * {@code IS NOT NULL}
2287     *
2288     * @param column      列名, lambda 展示
2289     * @param isEffective 是否有效
2290     */
2291    public <T> QueryWrapper isNotNull(LambdaGetter<T> column, boolean isEffective) {
2292        and(QueryMethods.column(column).isNotNull(isEffective));
2293        return this;
2294    }
2295
2296    /**
2297     * {@code IS NOT NULL}
2298     *
2299     * @param column      列名
2300     * @param isEffective 是否有效
2301     */
2302    public QueryWrapper isNotNull(String column, BooleanSupplier isEffective) {
2303        and(QueryMethods.column(column).isNotNull(isEffective));
2304        return this;
2305    }
2306
2307    /**
2308     * {@code IS NOT NULL}
2309     *
2310     * @param column      列名, lambda 展示
2311     * @param isEffective 是否有效
2312     */
2313    public <T> QueryWrapper isNotNull(LambdaGetter<T> column, BooleanSupplier isEffective) {
2314        and(QueryMethods.column(column).isNotNull(isEffective));
2315        return this;
2316    }
2317
2318
2319    ////////内部方法////////
2320
2321    /**
2322     * 获取 queryWrapper 的参数
2323     * 在构建 sql 的时候，需要保证 where 在 having 的前面
2324     */
2325    Object[] getAllValueArray() {
2326
2327        List<Object> withValues = null;
2328        if (with != null) {
2329            Object[] paramValues = with.getParamValues();
2330            if (ArrayUtil.isNotEmpty(paramValues)) {
2331                withValues = new ArrayList<>(Arrays.asList(paramValues));
2332
2333            }
2334        }
2335
2336        List<Object> columnValues = null;
2337        List<QueryColumn> selectColumns = getSelectColumns();
2338        if (CollectionUtil.isNotEmpty(selectColumns)) {
2339            for (QueryColumn selectColumn : selectColumns) {
2340                if (selectColumn instanceof HasParamsColumn) {
2341                    Object[] paramValues = ((HasParamsColumn) selectColumn).getParamValues();
2342                    if (ArrayUtil.isNotEmpty(paramValues)) {
2343                        if (columnValues == null) {
2344                            columnValues = new ArrayList<>(paramValues.length);
2345                        }
2346                        columnValues.addAll(Arrays.asList(paramValues));
2347                    }
2348                }
2349            }
2350        }
2351
2352        // select 子查询的参数：select * from (select ....)
2353        List<Object> tableValues = null;
2354        List<QueryTable> queryTables = getQueryTables();
2355        if (CollectionUtil.isNotEmpty(queryTables)) {
2356            for (QueryTable queryTable : queryTables) {
2357                Object[] tableValueArray = queryTable.getValueArray();
2358                if (tableValueArray.length > 0) {
2359                    if (tableValues == null) {
2360                        tableValues = new ArrayList<>(tableValueArray.length);
2361                    }
2362                    tableValues.addAll(Arrays.asList(tableValueArray));
2363                }
2364            }
2365        }
2366
2367        // join 子查询的参数：left join (select ...)
2368        List<Object> joinValues = null;
2369        List<Join> joins = getJoins();
2370        if (CollectionUtil.isNotEmpty(joins)) {
2371            for (Join join : joins) {
2372                QueryTable joinTable = join.getQueryTable();
2373                Object[] valueArray = joinTable.getValueArray();
2374                if (valueArray.length > 0) {
2375                    if (joinValues == null) {
2376                        joinValues = new ArrayList<>(valueArray.length);
2377                    }
2378                    joinValues.addAll(Arrays.asList(valueArray));
2379                }
2380                QueryCondition onCondition = join.getOnCondition();
2381                Object[] values = WrapperUtil.getValues(onCondition);
2382                if (values.length > 0) {
2383                    if (joinValues == null) {
2384                        joinValues = new ArrayList<>(values.length);
2385                    }
2386                    joinValues.addAll(Arrays.asList(values));
2387                }
2388            }
2389        }
2390
2391        // where 参数
2392        Object[] whereValues = WrapperUtil.getValues(whereQueryCondition);
2393
2394        // having 参数
2395        Object[] havingValues = WrapperUtil.getValues(havingQueryCondition);
2396
2397        Object[] paramValues = ArrayUtil.concat(whereValues, havingValues);
2398
2399        // orderBy 参数
2400        if (CollectionUtil.isNotEmpty(orderBys)) {
2401            for (QueryOrderBy orderBy : orderBys) {
2402                QueryColumn orderByColumn = orderBy.queryColumn;
2403                if (orderByColumn != null && orderByColumn instanceof HasParamsColumn) {
2404                    paramValues = ArrayUtil.concat(paramValues, ((HasParamsColumn) orderByColumn).getParamValues());
2405                }
2406            }
2407        }
2408
2409        // unions 参数
2410        if (CollectionUtil.isNotEmpty(unions)) {
2411            for (UnionWrapper union : unions) {
2412                QueryWrapper queryWrapper = union.getQueryWrapper();
2413                paramValues = ArrayUtil.concat(paramValues, queryWrapper.getAllValueArray());
2414            }
2415        }
2416
2417        Object[] returnValues = withValues == null ? FlexConsts.EMPTY_ARRAY : withValues.toArray();
2418        returnValues = columnValues != null ? ArrayUtil.concat(returnValues, columnValues.toArray()) : returnValues;
2419        returnValues = tableValues != null ? ArrayUtil.concat(returnValues, tableValues.toArray()) : returnValues;
2420        returnValues = joinValues != null ? ArrayUtil.concat(returnValues, joinValues.toArray()) : returnValues;
2421        returnValues = ArrayUtil.concat(returnValues, paramValues);
2422
2423        return returnValues;
2424    }
2425
2426
2427    /**
2428     * 获取 queryWrapper 的参数
2429     * 在构建 sql 的时候，需要保证 where 在 having 的前面
2430     */
2431    Object[] getJoinValueArray() {
2432        // join 子查询的参数：left join (select ...)
2433        List<Object> joinValues = null;
2434        List<Join> joins = getJoins();
2435        if (CollectionUtil.isNotEmpty(joins)) {
2436            for (Join join : joins) {
2437                QueryTable joinTable = join.getQueryTable();
2438                Object[] valueArray = joinTable.getValueArray();
2439                if (valueArray.length > 0) {
2440                    if (joinValues == null) {
2441                        joinValues = new ArrayList<>(valueArray.length);
2442                    }
2443                    joinValues.addAll(Arrays.asList(valueArray));
2444                }
2445                QueryCondition onCondition = join.getOnCondition();
2446                Object[] values = WrapperUtil.getValues(onCondition);
2447                if (values.length > 0) {
2448                    if (joinValues == null) {
2449                        joinValues = new ArrayList<>(values.length);
2450                    }
2451                    joinValues.addAll(Arrays.asList(values));
2452                }
2453            }
2454        }
2455
2456        return joinValues == null ? FlexConsts.EMPTY_ARRAY : joinValues.toArray();
2457    }
2458
2459
2460    /**
2461     * 获取 queryWrapper 的参数
2462     * 在构建 sql 的时候，需要保证 where 在 having 的前面
2463     */
2464    Object[] getConditionValueArray() {
2465        // where 参数
2466        Object[] whereValues = WrapperUtil.getValues(whereQueryCondition);
2467
2468        // having 参数
2469        Object[] havingValues = WrapperUtil.getValues(havingQueryCondition);
2470
2471        Object[] paramValues = ArrayUtil.concat(whereValues, havingValues);
2472
2473        // unions 参数
2474        if (CollectionUtil.isNotEmpty(unions)) {
2475            for (UnionWrapper union : unions) {
2476                QueryWrapper queryWrapper = union.getQueryWrapper();
2477                paramValues = ArrayUtil.concat(paramValues, queryWrapper.getAllValueArray());
2478            }
2479        }
2480
2481        return paramValues;
2482    }
2483
2484
2485    List<QueryWrapper> getChildSelect() {
2486
2487        List<QueryWrapper> tableChildQuery = null;
2488        List<QueryTable> queryTables = getQueryTables();
2489        if (CollectionUtil.isNotEmpty(queryTables)) {
2490            for (QueryTable queryTable : queryTables) {
2491                if (queryTable instanceof SelectQueryTable) {
2492                    if (tableChildQuery == null) {
2493                        tableChildQuery = new ArrayList<>();
2494                    }
2495                    tableChildQuery.add(((SelectQueryTable) queryTable).getQueryWrapper());
2496                }
2497            }
2498        }
2499
2500        List<QueryWrapper> whereChildQuery = WrapperUtil.getChildQueryWrapper(whereQueryCondition);
2501        List<QueryWrapper> havingChildQuery = WrapperUtil.getChildQueryWrapper(havingQueryCondition);
2502
2503        if (tableChildQuery == null && whereChildQuery.isEmpty() && havingChildQuery.isEmpty()) {
2504            return Collections.emptyList();
2505        }
2506
2507        List<QueryWrapper> childQueryWrappers = tableChildQuery == null ? new ArrayList<>()
2508            : new ArrayList<>(tableChildQuery);
2509        childQueryWrappers.addAll(whereChildQuery);
2510        childQueryWrappers.addAll(havingChildQuery);
2511
2512        return childQueryWrappers;
2513    }
2514
2515    public String toSQL() {
2516        String sql = DialectFactory.getDialect().forSelectByQuery(this);
2517        return SqlUtil.replaceSqlParams(sql, getAllValueArray());
2518    }
2519
2520    @Override
2521    public QueryWrapper clone() {
2522        return super.clone();
2523    }
2524
2525}