源代码

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