源代码

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