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[0] == null) {
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 orderByUnSafely(String... rawOrderBy) {
767        if (rawOrderBy == null || rawOrderBy[0] == null) {
768            return this;
769        }
770        for (String queryOrderBy : rawOrderBy) {
771            if (StringUtil.isNotBlank(queryOrderBy)) {
772                addOrderBy(new RawQueryOrderBy(queryOrderBy, false));
773            }
774        }
775        return this;
776    }
777
778
779    public QueryWrapper limit(Number rows) {
780        if (rows != null) {
781            setLimitRows(rows.longValue());
782        } else {
783            setLimitRows(null);
784        }
785        return this;
786    }
787
788    public QueryWrapper offset(Number offset) {
789        if (offset != null) {
790            setLimitOffset(offset.longValue());
791        } else {
792            setLimitOffset(null);
793        }
794        return this;
795    }
796
797    public QueryWrapper limit(Number offset, Number rows) {
798        offset(offset);
799        limit(rows);
800        return this;
801    }
802
803    public QueryWrapper datasource(String datasource) {
804        setDataSource(datasource);
805        return this;
806    }
807
808    public QueryWrapper hint(String hint) {
809        setHint(hint);
810        return this;
811    }
812
813
814    /////////MyBatis-Plus 兼容方法///////////////
815
816    /**
817     * 等于 {@code =}
818     *
819     * @param column 列名
820     * @param value  条件的值
821     */
822    public QueryWrapper eq(String column, Object value) {
823        and(QueryMethods.column(column).eq(value));
824        return this;
825    }
826
827    /**
828     * 等于 {@code =}
829     *
830     * @param column 列名, lambda 展示
831     * @param value  值
832     */
833    public <T> QueryWrapper eq(LambdaGetter<T> column, Object value) {
834        and(QueryMethods.column(column).eq(value));
835        return this;
836    }
837
838    /**
839     * 等于 {@code =}
840     *
841     * @param column      列名
842     * @param value       条件的值
843     * @param isEffective 是否有效
844     */
845    public QueryWrapper eq(String column, Object value, boolean isEffective) {
846        and(QueryMethods.column(column).eq(value).when(isEffective));
847        return this;
848    }
849
850    /**
851     * 等于 {@code =}
852     *
853     * @param column      列名, lambda 展示
854     * @param value       值
855     * @param isEffective 是否有效
856     */
857    public <T> QueryWrapper eq(LambdaGetter<T> column, Object value, boolean isEffective) {
858        and(QueryMethods.column(column).eq(value).when(isEffective));
859        return this;
860    }
861
862    /**
863     * 等于 {@code =}
864     *
865     * @param column      列名
866     * @param value       条件的值
867     * @param isEffective 是否有效
868     */
869    public <V> QueryWrapper eq(String column, V value, Predicate<V> isEffective) {
870        and(QueryMethods.column(column).eq(value, isEffective));
871        return this;
872    }
873
874    /**
875     * 等于 {@code =}
876     *
877     * @param column      列名, lambda 展示
878     * @param value       值
879     * @param isEffective 是否有效
880     */
881    public <T, V> QueryWrapper eq(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
882        and(QueryMethods.column(column).eq(value, isEffective));
883        return this;
884    }
885
886
887    /**
888     * 不等于 {@code !=}
889     *
890     * @param column 列名
891     * @param value  条件的值
892     */
893    public QueryWrapper ne(String column, Object value) {
894        and(QueryMethods.column(column).ne(value));
895        return this;
896    }
897
898    /**
899     * 不等于 {@code !=}
900     *
901     * @param column 列名, lambda 展示
902     * @param value  值
903     */
904    public <T> QueryWrapper ne(LambdaGetter<T> column, Object value) {
905        and(QueryMethods.column(column).ne(value));
906        return this;
907    }
908
909    /**
910     * 不等于 {@code !=}
911     *
912     * @param column      列名
913     * @param value       条件的值
914     * @param isEffective 是否有效
915     */
916    public QueryWrapper ne(String column, Object value, boolean isEffective) {
917        and(QueryMethods.column(column).ne(value).when(isEffective));
918        return this;
919    }
920
921    /**
922     * 不等于 {@code !=}
923     *
924     * @param column      列名, lambda 展示
925     * @param value       值
926     * @param isEffective 是否有效
927     */
928    public <T> QueryWrapper ne(LambdaGetter<T> column, Object value, boolean isEffective) {
929        and(QueryMethods.column(column).ne(value).when(isEffective));
930        return this;
931    }
932
933    /**
934     * 不等于 {@code !=}
935     *
936     * @param column      列名
937     * @param value       条件的值
938     * @param isEffective 是否有效
939     */
940    public <V> QueryWrapper ne(String column, V value, Predicate<V> isEffective) {
941        and(QueryMethods.column(column).ne(value, isEffective));
942        return this;
943    }
944
945    /**
946     * 不等于 {@code !=}
947     *
948     * @param column      列名, lambda 展示
949     * @param value       值
950     * @param isEffective 是否有效
951     */
952    public <T, V> QueryWrapper ne(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
953        and(QueryMethods.column(column).ne(value, isEffective));
954        return this;
955    }
956
957
958    /**
959     * 大于 {@code >}
960     *
961     * @param column 列名
962     * @param value  条件的值
963     */
964    public QueryWrapper gt(String column, Object value) {
965        and(QueryMethods.column(column).gt(value));
966        return this;
967    }
968
969    /**
970     * 大于 {@code >}
971     *
972     * @param column 列名, lambda 展示
973     * @param value  值
974     */
975    public <T> QueryWrapper gt(LambdaGetter<T> column, Object value) {
976        and(QueryMethods.column(column).gt(value));
977        return this;
978    }
979
980    /**
981     * 大于 {@code >}
982     *
983     * @param column      列名
984     * @param value       条件的值
985     * @param isEffective 是否有效
986     */
987    public QueryWrapper gt(String column, Object value, boolean isEffective) {
988        and(QueryMethods.column(column).gt(value).when(isEffective));
989        return this;
990    }
991
992    /**
993     * 大于 {@code >}
994     *
995     * @param column      列名, lambda 展示
996     * @param value       值
997     * @param isEffective 是否有效
998     */
999    public <T> QueryWrapper gt(LambdaGetter<T> column, Object value, boolean isEffective) {
1000        and(QueryMethods.column(column).gt(value).when(isEffective));
1001        return this;
1002    }
1003
1004    /**
1005     * 大于 {@code >}
1006     *
1007     * @param column      列名
1008     * @param value       条件的值
1009     * @param isEffective 是否有效
1010     */
1011    public <V> QueryWrapper gt(String column, V value, Predicate<V> isEffective) {
1012        and(QueryMethods.column(column).gt(value, isEffective));
1013        return this;
1014    }
1015
1016    /**
1017     * 大于 {@code >}
1018     *
1019     * @param column      列名, lambda 展示
1020     * @param value       值
1021     * @param isEffective 是否有效
1022     */
1023    public <T, V> QueryWrapper gt(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1024        and(QueryMethods.column(column).gt(value, isEffective));
1025        return this;
1026    }
1027
1028
1029    /**
1030     * 大于等于 {@code >=}
1031     *
1032     * @param column 列名
1033     * @param value  条件的值
1034     */
1035    public QueryWrapper ge(String column, Object value) {
1036        and(QueryMethods.column(column).ge(value));
1037        return this;
1038    }
1039
1040    /**
1041     * 大于等于 {@code >=}
1042     *
1043     * @param column 列名, lambda 展示
1044     * @param value  值
1045     */
1046    public <T> QueryWrapper ge(LambdaGetter<T> column, Object value) {
1047        and(QueryMethods.column(column).ge(value));
1048        return this;
1049    }
1050
1051    /**
1052     * 大于等于 {@code >=}
1053     *
1054     * @param column      列名
1055     * @param value       条件的值
1056     * @param isEffective 是否有效
1057     */
1058    public QueryWrapper ge(String column, Object value, boolean isEffective) {
1059        and(QueryMethods.column(column).ge(value).when(isEffective));
1060        return this;
1061    }
1062
1063    /**
1064     * 大于等于 {@code >=}
1065     *
1066     * @param column      列名, lambda 展示
1067     * @param value       值
1068     * @param isEffective 是否有效
1069     */
1070    public <T> QueryWrapper ge(LambdaGetter<T> column, Object value, boolean isEffective) {
1071        and(QueryMethods.column(column).ge(value).when(isEffective));
1072        return this;
1073    }
1074
1075    /**
1076     * 大于等于 {@code >=}
1077     *
1078     * @param column      列名
1079     * @param value       条件的值
1080     * @param isEffective 是否有效
1081     */
1082    public <V> QueryWrapper ge(String column, V value, Predicate<V> isEffective) {
1083        and(QueryMethods.column(column).ge(value, isEffective));
1084        return this;
1085    }
1086
1087    /**
1088     * 大于等于 {@code >=}
1089     *
1090     * @param column      列名, lambda 展示
1091     * @param value       值
1092     * @param isEffective 是否有效
1093     */
1094    public <T, V> QueryWrapper ge(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1095        and(QueryMethods.column(column).ge(value, isEffective));
1096        return this;
1097    }
1098
1099
1100    /**
1101     * 小于 {@code <}
1102     *
1103     * @param column 列名
1104     * @param value  条件的值
1105     */
1106    public QueryWrapper lt(String column, Object value) {
1107        and(QueryMethods.column(column).lt(value));
1108        return this;
1109    }
1110
1111    /**
1112     * 小于 {@code <}
1113     *
1114     * @param column 列名, lambda 展示
1115     * @param value  值
1116     */
1117    public <T> QueryWrapper lt(LambdaGetter<T> column, Object value) {
1118        and(QueryMethods.column(column).lt(value));
1119        return this;
1120    }
1121
1122    /**
1123     * 小于 {@code <}
1124     *
1125     * @param column      列名
1126     * @param value       条件的值
1127     * @param isEffective 是否有效
1128     */
1129    public QueryWrapper lt(String column, Object value, boolean isEffective) {
1130        and(QueryMethods.column(column).lt(value).when(isEffective));
1131        return this;
1132    }
1133
1134    /**
1135     * 小于 {@code <}
1136     *
1137     * @param column      列名, lambda 展示
1138     * @param value       值
1139     * @param isEffective 是否有效
1140     */
1141    public <T> QueryWrapper lt(LambdaGetter<T> column, Object value, boolean isEffective) {
1142        and(QueryMethods.column(column).lt(value).when(isEffective));
1143        return this;
1144    }
1145
1146    /**
1147     * 小于 {@code <}
1148     *
1149     * @param column      列名
1150     * @param value       条件的值
1151     * @param isEffective 是否有效
1152     */
1153    public <V> QueryWrapper lt(String column, V value, Predicate<V> isEffective) {
1154        and(QueryMethods.column(column).lt(value, isEffective));
1155        return this;
1156    }
1157
1158    /**
1159     * 小于 {@code <}
1160     *
1161     * @param column      列名, lambda 展示
1162     * @param value       值
1163     * @param isEffective 是否有效
1164     */
1165    public <T, V> QueryWrapper lt(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1166        and(QueryMethods.column(column).lt(value, isEffective));
1167        return this;
1168    }
1169
1170
1171    /**
1172     * 小于等于 {@code <=}
1173     *
1174     * @param column 列名
1175     * @param value  条件的值
1176     */
1177    public QueryWrapper le(String column, Object value) {
1178        and(QueryMethods.column(column).le(value));
1179        return this;
1180    }
1181
1182    /**
1183     * 小于等于 {@code <=}
1184     *
1185     * @param column 列名, lambda 展示
1186     * @param value  值
1187     */
1188    public <T> QueryWrapper le(LambdaGetter<T> column, Object value) {
1189        and(QueryMethods.column(column).le(value));
1190        return this;
1191    }
1192
1193    /**
1194     * 小于等于 {@code <=}
1195     *
1196     * @param column      列名
1197     * @param value       条件的值
1198     * @param isEffective 是否有效
1199     */
1200    public QueryWrapper le(String column, Object value, boolean isEffective) {
1201        and(QueryMethods.column(column).le(value).when(isEffective));
1202        return this;
1203    }
1204
1205    /**
1206     * 小于等于 {@code <=}
1207     *
1208     * @param column      列名, lambda 展示
1209     * @param value       值
1210     * @param isEffective 是否有效
1211     */
1212    public <T> QueryWrapper le(LambdaGetter<T> column, Object value, boolean isEffective) {
1213        and(QueryMethods.column(column).le(value).when(isEffective));
1214        return this;
1215    }
1216
1217    /**
1218     * 小于等于 {@code <=}
1219     *
1220     * @param column      列名
1221     * @param value       条件的值
1222     * @param isEffective 是否有效
1223     */
1224    public <V> QueryWrapper le(String column, V value, Predicate<V> isEffective) {
1225        and(QueryMethods.column(column).le(value, isEffective));
1226        return this;
1227    }
1228
1229    /**
1230     * 小于等于 {@code <=}
1231     *
1232     * @param column      列名, lambda 展示
1233     * @param value       值
1234     * @param isEffective 是否有效
1235     */
1236    public <T, V> QueryWrapper le(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1237        and(QueryMethods.column(column).le(value, isEffective));
1238        return this;
1239    }
1240
1241
1242    /**
1243     * {@code IN(value)}
1244     *
1245     * @param column 列名
1246     * @param values 条件的值
1247     */
1248    public QueryWrapper in(String column, Object... values) {
1249        and(QueryMethods.column(column).in(values));
1250        return this;
1251    }
1252
1253    /**
1254     * {@code IN(value)}
1255     *
1256     * @param column 列名, lambda 展示
1257     * @param values 值
1258     */
1259    public <T> QueryWrapper in(LambdaGetter<T> column, Object... values) {
1260        and(QueryMethods.column(column).in(values));
1261        return this;
1262    }
1263
1264
1265    /**
1266     * {@code IN(value)}
1267     *
1268     * @param column       列名
1269     * @param queryWrapper 条件的值
1270     */
1271    public QueryWrapper in(String column, QueryWrapper queryWrapper) {
1272        and(QueryMethods.column(column).in(queryWrapper));
1273        return this;
1274    }
1275
1276
1277    /**
1278     * {@code IN(value)}
1279     *
1280     * @param column       列名, lambda 展示
1281     * @param queryWrapper 值
1282     */
1283    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper) {
1284        and(QueryMethods.column(column).in(queryWrapper));
1285        return this;
1286    }
1287
1288
1289    /**
1290     * {@code IN(value)}
1291     *
1292     * @param column 列名
1293     * @param values 条件的值
1294     */
1295    public QueryWrapper in(String column, Collection<?> values) {
1296        and(QueryMethods.column(column).in(values));
1297        return this;
1298    }
1299
1300    /**
1301     * {@code IN(value)}
1302     *
1303     * @param column 列名, lambda 展示
1304     * @param values 值
1305     */
1306    public <T> QueryWrapper in(LambdaGetter<T> column, Collection<?> values) {
1307        and(QueryMethods.column(column).in(values));
1308        return this;
1309    }
1310
1311
1312    /**
1313     * {@code IN(value)}
1314     *
1315     * @param column 列名
1316     * @param values 条件的值
1317     */
1318    public QueryWrapper in(String column, Object[] values, boolean isEffective) {
1319        and(QueryMethods.column(column).in(values, isEffective));
1320        return this;
1321    }
1322
1323    /**
1324     * {@code IN(value)}
1325     *
1326     * @param column 列名, lambda 展示
1327     * @param values 值
1328     */
1329    public <T> QueryWrapper in(LambdaGetter<T> column, Object[] values, boolean isEffective) {
1330        and(QueryMethods.column(column).in(values, isEffective));
1331        return this;
1332    }
1333
1334
1335    /**
1336     * {@code IN(value)}
1337     *
1338     * @param column 列名
1339     * @param values 条件的值
1340     */
1341    public QueryWrapper in(String column, Collection<?> values, boolean isEffective) {
1342        and(QueryMethods.column(column).in(values, isEffective));
1343        return this;
1344    }
1345
1346    /**
1347     * {@code IN(value)}
1348     *
1349     * @param column 列名, lambda 展示
1350     * @param values 值
1351     */
1352    public <T> QueryWrapper in(LambdaGetter<T> column, Collection<?> values, boolean isEffective) {
1353        and(QueryMethods.column(column).in(values, isEffective));
1354        return this;
1355    }
1356
1357
1358    /**
1359     * {@code IN(value)}
1360     *
1361     * @param column       列名
1362     * @param queryWrapper 条件的值
1363     */
1364    public QueryWrapper in(String column, QueryWrapper queryWrapper, boolean isEffective) {
1365        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1366        return this;
1367    }
1368
1369
1370    /**
1371     * {@code IN(value)}
1372     *
1373     * @param column       列名, lambda 展示
1374     * @param queryWrapper 值
1375     */
1376    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper, boolean isEffective) {
1377        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1378        return this;
1379    }
1380
1381
1382    /**
1383     * {@code IN(value)}
1384     *
1385     * @param column       列名
1386     * @param queryWrapper 条件的值
1387     */
1388    public QueryWrapper in(String column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1389        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1390        return this;
1391    }
1392
1393
1394    /**
1395     * {@code IN(value)}
1396     *
1397     * @param column       列名, lambda 展示
1398     * @param queryWrapper 值
1399     */
1400    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1401        and(QueryMethods.column(column).in(queryWrapper, isEffective));
1402        return this;
1403    }
1404
1405
1406    /**
1407     * {@code NOT IN(value)}
1408     *
1409     * @param column 列名
1410     * @param values 条件的值
1411     */
1412    public QueryWrapper notIn(String column, Object... values) {
1413        and(QueryMethods.column(column).notIn(values));
1414        return this;
1415    }
1416
1417    /**
1418     * {@code NOT IN(value)}
1419     *
1420     * @param column 列名, lambda 展示
1421     * @param values 值
1422     */
1423    public <T> QueryWrapper notIn(LambdaGetter<T> column, Object... values) {
1424        and(QueryMethods.column(column).notIn(values));
1425        return this;
1426    }
1427
1428
1429    /**
1430     * {@code NOT IN(value)}
1431     *
1432     * @param column       列名
1433     * @param queryWrapper 条件的值
1434     */
1435    public QueryWrapper notIn(String column, QueryWrapper queryWrapper) {
1436        and(QueryMethods.column(column).notIn(queryWrapper));
1437        return this;
1438    }
1439
1440
1441    /**
1442     * {@code NOT IN(value)}
1443     *
1444     * @param column       列名, lambda 展示
1445     * @param queryWrapper 值
1446     */
1447    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper) {
1448        and(QueryMethods.column(column).notIn(queryWrapper));
1449        return this;
1450    }
1451
1452
1453    /**
1454     * {@code NOT IN(value)}
1455     *
1456     * @param column 列名
1457     * @param values 条件的值
1458     */
1459    public QueryWrapper notIn(String column, Collection<?> values) {
1460        and(QueryMethods.column(column).notIn(values));
1461        return this;
1462    }
1463
1464    /**
1465     * {@code NOT IN(value)}
1466     *
1467     * @param column 列名, lambda 展示
1468     * @param values 值
1469     */
1470    public <T> QueryWrapper notIn(LambdaGetter<T> column, Collection<?> values) {
1471        and(QueryMethods.column(column).notIn(values));
1472        return this;
1473    }
1474
1475
1476    /**
1477     * {@code NOT IN(value)}
1478     *
1479     * @param column 列名
1480     * @param values 条件的值
1481     */
1482    public QueryWrapper notIn(String column, Object[] values, boolean isEffective) {
1483        and(QueryMethods.column(column).notIn(values, isEffective));
1484        return this;
1485    }
1486
1487    /**
1488     * {@code NOT IN(value)}
1489     *
1490     * @param column 列名, lambda 展示
1491     * @param values 值
1492     */
1493    public <T> QueryWrapper notIn(LambdaGetter<T> column, Object[] values, boolean isEffective) {
1494        and(QueryMethods.column(column).notIn(values, isEffective));
1495        return this;
1496    }
1497
1498
1499    /**
1500     * {@code NOT IN(value)}
1501     *
1502     * @param column 列名
1503     * @param values 条件的值
1504     */
1505    public QueryWrapper notIn(String column, Collection<?> values, boolean isEffective) {
1506        and(QueryMethods.column(column).notIn(values, isEffective));
1507        return this;
1508    }
1509
1510    /**
1511     * {@code NOT IN(value)}
1512     *
1513     * @param column 列名, lambda 展示
1514     * @param values 值
1515     */
1516    public <T> QueryWrapper notIn(LambdaGetter<T> column, Collection<?> values, boolean isEffective) {
1517        and(QueryMethods.column(column).notIn(values, isEffective));
1518        return this;
1519    }
1520
1521
1522    /**
1523     * {@code NOT IN(value)}
1524     *
1525     * @param column       列名
1526     * @param queryWrapper 条件的值
1527     */
1528    public QueryWrapper notIn(String column, QueryWrapper queryWrapper, boolean isEffective) {
1529        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1530        return this;
1531    }
1532
1533
1534    /**
1535     * {@code NOT IN(value)}
1536     *
1537     * @param column       列名, lambda 展示
1538     * @param queryWrapper 值
1539     */
1540    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper, boolean isEffective) {
1541        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1542        return this;
1543    }
1544
1545
1546    /**
1547     * {@code NOT IN(value)}
1548     *
1549     * @param column       列名
1550     * @param queryWrapper 条件的值
1551     */
1552    public QueryWrapper notIn(String column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1553        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1554        return this;
1555    }
1556
1557
1558    /**
1559     * {@code NOT IN(value)}
1560     *
1561     * @param column       列名, lambda 展示
1562     * @param queryWrapper 值
1563     */
1564    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
1565        and(QueryMethods.column(column).notIn(queryWrapper, isEffective));
1566        return this;
1567    }
1568
1569
1570    /**
1571     * {@code BETWEEN start AND end}
1572     *
1573     * @param column 列名
1574     * @param start  开始的值
1575     * @param end    结束的值
1576     */
1577    public QueryWrapper between(String column, Object start, Object end) {
1578        and(QueryMethods.column(column).between(start, end));
1579        return this;
1580    }
1581
1582    /**
1583     * {@code BETWEEN start AND end}
1584     *
1585     * @param column 列名
1586     * @param start  开始的值
1587     * @param end    结束的值
1588     */
1589    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end) {
1590        and(QueryMethods.column(column).between(start, end));
1591        return this;
1592    }
1593
1594    /**
1595     * {@code BETWEEN start AND end}
1596     *
1597     * @param column 列名
1598     * @param start  开始的值
1599     * @param end    结束的值
1600     */
1601    public QueryWrapper between(String column, Object start, Object end, boolean isEffective) {
1602        and(QueryMethods.column(column).between(start, end, isEffective));
1603        return this;
1604    }
1605
1606    /**
1607     * {@code BETWEEN start AND end}
1608     *
1609     * @param column 列名
1610     * @param start  开始的值
1611     * @param end    结束的值
1612     */
1613    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end, boolean isEffective) {
1614        and(QueryMethods.column(column).between(start, end, isEffective));
1615        return this;
1616    }
1617
1618
1619    /**
1620     * {@code BETWEEN start AND end}
1621     *
1622     * @param column 列名
1623     * @param start  开始的值
1624     * @param end    结束的值
1625     */
1626    public QueryWrapper between(String column, Object start, Object end, BooleanSupplier isEffective) {
1627        and(QueryMethods.column(column).between(start, end, isEffective));
1628        return this;
1629    }
1630
1631    /**
1632     * {@code BETWEEN start AND end}
1633     *
1634     * @param column 列名
1635     * @param start  开始的值
1636     * @param end    结束的值
1637     */
1638    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end, BooleanSupplier isEffective) {
1639        and(QueryMethods.column(column).between(start, end, isEffective));
1640        return this;
1641    }
1642
1643
1644    /**
1645     * {@code NOT BETWEEN start AND end}
1646     *
1647     * @param column 列名
1648     * @param start  开始的值
1649     * @param end    结束的值
1650     */
1651    public QueryWrapper notBetween(String column, Object start, Object end) {
1652        and(QueryMethods.column(column).notBetween(start, end));
1653        return this;
1654    }
1655
1656    /**
1657     * {@code NOT BETWEEN start AND end}
1658     *
1659     * @param column 列名
1660     * @param start  开始的值
1661     * @param end    结束的值
1662     */
1663    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end) {
1664        and(QueryMethods.column(column).notBetween(start, end));
1665        return this;
1666    }
1667
1668    /**
1669     * {@code NOT BETWEEN start AND end}
1670     *
1671     * @param column 列名
1672     * @param start  开始的值
1673     * @param end    结束的值
1674     */
1675    public QueryWrapper notBetween(String column, Object start, Object end, boolean isEffective) {
1676        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1677        return this;
1678    }
1679
1680    /**
1681     * {@code NOT BETWEEN start AND end}
1682     *
1683     * @param column 列名
1684     * @param start  开始的值
1685     * @param end    结束的值
1686     */
1687    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end, boolean isEffective) {
1688        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1689        return this;
1690    }
1691
1692
1693    /**
1694     * {@code NOT BETWEEN start AND end}
1695     *
1696     * @param column 列名
1697     * @param start  开始的值
1698     * @param end    结束的值
1699     */
1700    public QueryWrapper notBetween(String column, Object start, Object end, BooleanSupplier isEffective) {
1701        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1702        return this;
1703    }
1704
1705    /**
1706     * {@code NOT BETWEEN start AND end}
1707     *
1708     * @param column 列名
1709     * @param start  开始的值
1710     * @param end    结束的值
1711     */
1712    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end, BooleanSupplier isEffective) {
1713        and(QueryMethods.column(column).notBetween(start, end, isEffective));
1714        return this;
1715    }
1716
1717
1718    /**
1719     * {@code LIKE %value%}
1720     *
1721     * @param column 列名
1722     * @param value  条件的值
1723     */
1724    public QueryWrapper like(String column, Object value) {
1725        and(QueryMethods.column(column).like(value));
1726        return this;
1727    }
1728
1729    /**
1730     * {@code LIKE %value%}
1731     *
1732     * @param column 列名, lambda 展示
1733     * @param value  值
1734     */
1735    public <T> QueryWrapper like(LambdaGetter<T> column, Object value) {
1736        and(QueryMethods.column(column).like(value));
1737        return this;
1738    }
1739
1740    /**
1741     * {@code LIKE %value%}
1742     *
1743     * @param column      列名
1744     * @param value       条件的值
1745     * @param isEffective 是否有效
1746     */
1747    public QueryWrapper like(String column, Object value, boolean isEffective) {
1748        and(QueryMethods.column(column).like(value).when(isEffective));
1749        return this;
1750    }
1751
1752    /**
1753     * {@code LIKE %value%}
1754     *
1755     * @param column      列名, lambda 展示
1756     * @param value       值
1757     * @param isEffective 是否有效
1758     */
1759    public <T> QueryWrapper like(LambdaGetter<T> column, Object value, boolean isEffective) {
1760        and(QueryMethods.column(column).like(value).when(isEffective));
1761        return this;
1762    }
1763
1764    /**
1765     * {@code LIKE %value%}
1766     *
1767     * @param column      列名
1768     * @param value       条件的值
1769     * @param isEffective 是否有效
1770     */
1771    public <V> QueryWrapper like(String column, V value, Predicate<V> isEffective) {
1772        and(QueryMethods.column(column).like(value, isEffective));
1773        return this;
1774    }
1775
1776    /**
1777     * {@code LIKE %value%}
1778     *
1779     * @param column      列名, lambda 展示
1780     * @param value       值
1781     * @param isEffective 是否有效
1782     */
1783    public <T, V> QueryWrapper like(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1784        and(QueryMethods.column(column).like(value, isEffective));
1785        return this;
1786    }
1787
1788
1789    /**
1790     * {@code LIKE value%}
1791     *
1792     * @param column 列名
1793     * @param value  条件的值
1794     */
1795    public QueryWrapper likeLeft(String column, Object value) {
1796        and(QueryMethods.column(column).likeLeft(value));
1797        return this;
1798    }
1799
1800    /**
1801     * {@code LIKE value%}
1802     *
1803     * @param column 列名, lambda 展示
1804     * @param value  值
1805     */
1806    public <T> QueryWrapper likeLeft(LambdaGetter<T> column, Object value) {
1807        and(QueryMethods.column(column).likeLeft(value));
1808        return this;
1809    }
1810
1811    /**
1812     * {@code LIKE value%}
1813     *
1814     * @param column      列名
1815     * @param value       条件的值
1816     * @param isEffective 是否有效
1817     */
1818    public QueryWrapper likeLeft(String column, Object value, boolean isEffective) {
1819        and(QueryMethods.column(column).likeLeft(value).when(isEffective));
1820        return this;
1821    }
1822
1823    /**
1824     * {@code LIKE value%}
1825     *
1826     * @param column      列名, lambda 展示
1827     * @param value       值
1828     * @param isEffective 是否有效
1829     */
1830    public <T> QueryWrapper likeLeft(LambdaGetter<T> column, Object value, boolean isEffective) {
1831        and(QueryMethods.column(column).likeLeft(value).when(isEffective));
1832        return this;
1833    }
1834
1835    /**
1836     * {@code LIKE value%}
1837     *
1838     * @param column      列名
1839     * @param value       条件的值
1840     * @param isEffective 是否有效
1841     */
1842    public <V> QueryWrapper likeLeft(String column, V value, Predicate<V> isEffective) {
1843        and(QueryMethods.column(column).likeLeft(value, isEffective));
1844        return this;
1845    }
1846
1847    /**
1848     * {@code LIKE value%}
1849     *
1850     * @param column      列名, lambda 展示
1851     * @param value       值
1852     * @param isEffective 是否有效
1853     */
1854    public <T, V> QueryWrapper likeLeft(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1855        and(QueryMethods.column(column).likeLeft(value, isEffective));
1856        return this;
1857    }
1858
1859
1860    /**
1861     * {@code LIKE %value}
1862     *
1863     * @param column 列名
1864     * @param value  条件的值
1865     */
1866    public QueryWrapper likeRight(String column, Object value) {
1867        and(QueryMethods.column(column).likeRight(value));
1868        return this;
1869    }
1870
1871    /**
1872     * {@code LIKE %value}
1873     *
1874     * @param column 列名, lambda 展示
1875     * @param value  值
1876     */
1877    public <T> QueryWrapper likeRight(LambdaGetter<T> column, Object value) {
1878        and(QueryMethods.column(column).likeRight(value));
1879        return this;
1880    }
1881
1882    /**
1883     * {@code LIKE %value}
1884     *
1885     * @param column      列名
1886     * @param value       条件的值
1887     * @param isEffective 是否有效
1888     */
1889    public QueryWrapper likeRight(String column, Object value, boolean isEffective) {
1890        and(QueryMethods.column(column).likeRight(value).when(isEffective));
1891        return this;
1892    }
1893
1894    /**
1895     * {@code LIKE %value}
1896     *
1897     * @param column      列名, lambda 展示
1898     * @param value       值
1899     * @param isEffective 是否有效
1900     */
1901    public <T> QueryWrapper likeRight(LambdaGetter<T> column, Object value, boolean isEffective) {
1902        and(QueryMethods.column(column).likeRight(value).when(isEffective));
1903        return this;
1904    }
1905
1906    /**
1907     * {@code LIKE %value}
1908     *
1909     * @param column      列名
1910     * @param value       条件的值
1911     * @param isEffective 是否有效
1912     */
1913    public <V> QueryWrapper likeRight(String column, V value, Predicate<V> isEffective) {
1914        and(QueryMethods.column(column).likeRight(value, isEffective));
1915        return this;
1916    }
1917
1918    /**
1919     * {@code LIKE %value}
1920     *
1921     * @param column      列名, lambda 展示
1922     * @param value       值
1923     * @param isEffective 是否有效
1924     */
1925    public <T, V> QueryWrapper likeRight(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1926        and(QueryMethods.column(column).likeRight(value, isEffective));
1927        return this;
1928    }
1929
1930
1931    /**
1932     * {@code NOT LIKE %value%}
1933     *
1934     * @param column 列名
1935     * @param value  条件的值
1936     */
1937    public QueryWrapper notLike(String column, Object value) {
1938        and(QueryMethods.column(column).notLike(value));
1939        return this;
1940    }
1941
1942    /**
1943     * {@code NOT LIKE %value%}
1944     *
1945     * @param column 列名, lambda 展示
1946     * @param value  值
1947     */
1948    public <T> QueryWrapper notLike(LambdaGetter<T> column, Object value) {
1949        and(QueryMethods.column(column).notLike(value));
1950        return this;
1951    }
1952
1953    /**
1954     * {@code NOT LIKE %value%}
1955     *
1956     * @param column      列名
1957     * @param value       条件的值
1958     * @param isEffective 是否有效
1959     */
1960    public QueryWrapper notLike(String column, Object value, boolean isEffective) {
1961        and(QueryMethods.column(column).notLike(value).when(isEffective));
1962        return this;
1963    }
1964
1965    /**
1966     * {@code NOT LIKE %value%}
1967     *
1968     * @param column      列名, lambda 展示
1969     * @param value       值
1970     * @param isEffective 是否有效
1971     */
1972    public <T> QueryWrapper notLike(LambdaGetter<T> column, Object value, boolean isEffective) {
1973        and(QueryMethods.column(column).notLike(value).when(isEffective));
1974        return this;
1975    }
1976
1977    /**
1978     * {@code NOT LIKE %value%}
1979     *
1980     * @param column      列名
1981     * @param value       条件的值
1982     * @param isEffective 是否有效
1983     */
1984    public <V> QueryWrapper notLike(String column, V value, Predicate<V> isEffective) {
1985        and(QueryMethods.column(column).notLike(value, isEffective));
1986        return this;
1987    }
1988
1989    /**
1990     * {@code NOT LIKE %value%}
1991     *
1992     * @param column      列名, lambda 展示
1993     * @param value       值
1994     * @param isEffective 是否有效
1995     */
1996    public <T, V> QueryWrapper notLike(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
1997        and(QueryMethods.column(column).notLike(value, isEffective));
1998        return this;
1999    }
2000
2001
2002    /**
2003     * {@code NOT LIKE value%}
2004     *
2005     * @param column 列名
2006     * @param value  条件的值
2007     */
2008    public QueryWrapper notLikeLeft(String column, Object value) {
2009        and(QueryMethods.column(column).notLikeLeft(value));
2010        return this;
2011    }
2012
2013    /**
2014     * {@code NOT LIKE value%}
2015     *
2016     * @param column 列名, lambda 展示
2017     * @param value  值
2018     */
2019    public <T> QueryWrapper notLikeLeft(LambdaGetter<T> column, Object value) {
2020        and(QueryMethods.column(column).notLikeLeft(value));
2021        return this;
2022    }
2023
2024    /**
2025     * {@code NOT LIKE value%}
2026     *
2027     * @param column      列名
2028     * @param value       条件的值
2029     * @param isEffective 是否有效
2030     */
2031    public QueryWrapper notLikeLeft(String column, Object value, boolean isEffective) {
2032        and(QueryMethods.column(column).notLikeLeft(value).when(isEffective));
2033        return this;
2034    }
2035
2036    /**
2037     * {@code NOT LIKE value%}
2038     *
2039     * @param column      列名, lambda 展示
2040     * @param value       值
2041     * @param isEffective 是否有效
2042     */
2043    public <T> QueryWrapper notLikeLeft(LambdaGetter<T> column, Object value, boolean isEffective) {
2044        and(QueryMethods.column(column).notLikeLeft(value).when(isEffective));
2045        return this;
2046    }
2047
2048    /**
2049     * {@code NOT LIKE value%}
2050     *
2051     * @param column      列名
2052     * @param value       条件的值
2053     * @param isEffective 是否有效
2054     */
2055    public <V> QueryWrapper notLikeLeft(String column, V value, Predicate<V> isEffective) {
2056        and(QueryMethods.column(column).notLikeLeft(value, isEffective));
2057        return this;
2058    }
2059
2060    /**
2061     * {@code NOT LIKE value%}
2062     *
2063     * @param column      列名, lambda 展示
2064     * @param value       值
2065     * @param isEffective 是否有效
2066     */
2067    public <T, V> QueryWrapper notLikeLeft(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
2068        and(QueryMethods.column(column).notLikeLeft(value, isEffective));
2069        return this;
2070    }
2071
2072
2073    /**
2074     * {@code NOT LIKE %value}
2075     *
2076     * @param column 列名
2077     * @param value  条件的值
2078     */
2079    public QueryWrapper notLikeRight(String column, Object value) {
2080        and(QueryMethods.column(column).notLikeRight(value));
2081        return this;
2082    }
2083
2084    /**
2085     * {@code NOT LIKE %value}
2086     *
2087     * @param column 列名, lambda 展示
2088     * @param value  值
2089     */
2090    public <T> QueryWrapper notLikeRight(LambdaGetter<T> column, Object value) {
2091        and(QueryMethods.column(column).notLikeRight(value));
2092        return this;
2093    }
2094
2095    /**
2096     * {@code NOT LIKE %value}
2097     *
2098     * @param column      列名
2099     * @param value       条件的值
2100     * @param isEffective 是否有效
2101     */
2102    public QueryWrapper notLikeRight(String column, Object value, boolean isEffective) {
2103        and(QueryMethods.column(column).notLikeRight(value).when(isEffective));
2104        return this;
2105    }
2106
2107    /**
2108     * {@code NOT LIKE %value}
2109     *
2110     * @param column      列名, lambda 展示
2111     * @param value       值
2112     * @param isEffective 是否有效
2113     */
2114    public <T> QueryWrapper notLikeRight(LambdaGetter<T> column, Object value, boolean isEffective) {
2115        and(QueryMethods.column(column).notLikeRight(value).when(isEffective));
2116        return this;
2117    }
2118
2119    /**
2120     * {@code NOT LIKE %value}
2121     *
2122     * @param column      列名
2123     * @param value       条件的值
2124     * @param isEffective 是否有效
2125     */
2126    public <V> QueryWrapper notLikeRight(String column, V value, Predicate<V> isEffective) {
2127        and(QueryMethods.column(column).notLikeRight(value, isEffective));
2128        return this;
2129    }
2130
2131    /**
2132     * {@code NOT LIKE %value}
2133     *
2134     * @param column      列名, lambda 展示
2135     * @param value       值
2136     * @param isEffective 是否有效
2137     */
2138    public <T, V> QueryWrapper notLikeRight(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
2139        and(QueryMethods.column(column).notLikeRight(value, isEffective));
2140        return this;
2141    }
2142
2143
2144    /**
2145     * {@code IS NULL}
2146     *
2147     * @param column 列名
2148     */
2149    public QueryWrapper isNull(String column) {
2150        and(QueryMethods.column(column).isNull());
2151        return this;
2152    }
2153
2154    /**
2155     * {@code IS NULL}
2156     *
2157     * @param column 列名, lambda 展示
2158     */
2159    public <T> QueryWrapper isNull(LambdaGetter<T> column) {
2160        and(QueryMethods.column(column).isNull());
2161        return this;
2162    }
2163
2164    /**
2165     * {@code IS NULL}
2166     *
2167     * @param column      列名
2168     * @param isEffective 是否有效
2169     */
2170    public QueryWrapper isNull(String column, boolean isEffective) {
2171        and(QueryMethods.column(column).isNull(isEffective));
2172        return this;
2173    }
2174
2175    /**
2176     * {@code IS NULL}
2177     *
2178     * @param column      列名, lambda 展示
2179     * @param isEffective 是否有效
2180     */
2181    public <T> QueryWrapper isNull(LambdaGetter<T> column, boolean isEffective) {
2182        and(QueryMethods.column(column).isNull(isEffective));
2183        return this;
2184    }
2185
2186    /**
2187     * {@code IS NULL}
2188     *
2189     * @param column      列名
2190     * @param isEffective 是否有效
2191     */
2192    public QueryWrapper isNull(String column, BooleanSupplier isEffective) {
2193        and(QueryMethods.column(column).isNull(isEffective));
2194        return this;
2195    }
2196
2197    /**
2198     * {@code IS NULL}
2199     *
2200     * @param column      列名, lambda 展示
2201     * @param isEffective 是否有效
2202     */
2203    public <T> QueryWrapper isNull(LambdaGetter<T> column, BooleanSupplier isEffective) {
2204        and(QueryMethods.column(column).isNull(isEffective));
2205        return this;
2206    }
2207
2208
2209    /**
2210     * {@code IS NOT NULL}
2211     *
2212     * @param column 列名
2213     */
2214    public QueryWrapper isNotNull(String column) {
2215        and(QueryMethods.column(column).isNotNull());
2216        return this;
2217    }
2218
2219    /**
2220     * {@code IS NOT NULL}
2221     *
2222     * @param column 列名, lambda 展示
2223     */
2224    public <T> QueryWrapper isNotNull(LambdaGetter<T> column) {
2225        and(QueryMethods.column(column).isNotNull());
2226        return this;
2227    }
2228
2229    /**
2230     * {@code IS NOT NULL}
2231     *
2232     * @param column      列名
2233     * @param isEffective 是否有效
2234     */
2235    public QueryWrapper isNotNull(String column, boolean isEffective) {
2236        and(QueryMethods.column(column).isNotNull(isEffective));
2237        return this;
2238    }
2239
2240    /**
2241     * {@code IS NOT NULL}
2242     *
2243     * @param column      列名, lambda 展示
2244     * @param isEffective 是否有效
2245     */
2246    public <T> QueryWrapper isNotNull(LambdaGetter<T> column, boolean isEffective) {
2247        and(QueryMethods.column(column).isNotNull(isEffective));
2248        return this;
2249    }
2250
2251    /**
2252     * {@code IS NOT NULL}
2253     *
2254     * @param column      列名
2255     * @param isEffective 是否有效
2256     */
2257    public QueryWrapper isNotNull(String column, BooleanSupplier isEffective) {
2258        and(QueryMethods.column(column).isNotNull(isEffective));
2259        return this;
2260    }
2261
2262    /**
2263     * {@code IS NOT NULL}
2264     *
2265     * @param column      列名, lambda 展示
2266     * @param isEffective 是否有效
2267     */
2268    public <T> QueryWrapper isNotNull(LambdaGetter<T> column, BooleanSupplier isEffective) {
2269        and(QueryMethods.column(column).isNotNull(isEffective));
2270        return this;
2271    }
2272
2273
2274    ////////内部方法////////
2275
2276    /**
2277     * 获取 queryWrapper 的参数
2278     * 在构建 sql 的时候，需要保证 where 在 having 的前面
2279     */
2280    Object[] getAllValueArray() {
2281
2282        List<Object> withValues = null;
2283        if (with != null) {
2284            Object[] paramValues = with.getParamValues();
2285            if (ArrayUtil.isNotEmpty(paramValues)) {
2286                withValues = new ArrayList<>(Arrays.asList(paramValues));
2287
2288            }
2289        }
2290
2291        List<Object> columnValues = null;
2292        List<QueryColumn> selectColumns = getSelectColumns();
2293        if (CollectionUtil.isNotEmpty(selectColumns)) {
2294            for (QueryColumn selectColumn : selectColumns) {
2295                if (selectColumn instanceof HasParamsColumn) {
2296                    Object[] paramValues = ((HasParamsColumn) selectColumn).getParamValues();
2297                    if (ArrayUtil.isNotEmpty(paramValues)) {
2298                        if (columnValues == null) {
2299                            columnValues = new ArrayList<>(paramValues.length);
2300                        }
2301                        columnValues.addAll(Arrays.asList(paramValues));
2302                    }
2303                }
2304            }
2305        }
2306
2307        // select 子查询的参数：select * from (select ....)
2308        List<Object> tableValues = null;
2309        List<QueryTable> queryTables = getQueryTables();
2310        if (CollectionUtil.isNotEmpty(queryTables)) {
2311            for (QueryTable queryTable : queryTables) {
2312                Object[] tableValueArray = queryTable.getValueArray();
2313                if (tableValueArray.length > 0) {
2314                    if (tableValues == null) {
2315                        tableValues = new ArrayList<>(tableValueArray.length);
2316                    }
2317                    tableValues.addAll(Arrays.asList(tableValueArray));
2318                }
2319            }
2320        }
2321
2322        // join 子查询的参数：left join (select ...)
2323        List<Object> joinValues = null;
2324        List<Join> joins = getJoins();
2325        if (CollectionUtil.isNotEmpty(joins)) {
2326            for (Join join : joins) {
2327                QueryTable joinTable = join.getQueryTable();
2328                Object[] valueArray = joinTable.getValueArray();
2329                if (valueArray.length > 0) {
2330                    if (joinValues == null) {
2331                        joinValues = new ArrayList<>(valueArray.length);
2332                    }
2333                    joinValues.addAll(Arrays.asList(valueArray));
2334                }
2335                QueryCondition onCondition = join.getOnCondition();
2336                Object[] values = WrapperUtil.getValues(onCondition);
2337                if (values.length > 0) {
2338                    if (joinValues == null) {
2339                        joinValues = new ArrayList<>(values.length);
2340                    }
2341                    joinValues.addAll(Arrays.asList(values));
2342                }
2343            }
2344        }
2345
2346        // where 参数
2347        Object[] whereValues = WrapperUtil.getValues(whereQueryCondition);
2348
2349        // having 参数
2350        Object[] havingValues = WrapperUtil.getValues(havingQueryCondition);
2351
2352        Object[] paramValues = ArrayUtil.concat(whereValues, havingValues);
2353
2354        // orderBy 参数
2355        if (CollectionUtil.isNotEmpty(orderBys)) {
2356            for (QueryOrderBy orderBy : orderBys) {
2357                QueryColumn orderByColumn = orderBy.queryColumn;
2358                if (orderByColumn != null && orderByColumn instanceof HasParamsColumn) {
2359                    paramValues = ArrayUtil.concat(paramValues, ((HasParamsColumn) orderByColumn).getParamValues());
2360                }
2361            }
2362        }
2363
2364        // unions 参数
2365        if (CollectionUtil.isNotEmpty(unions)) {
2366            for (UnionWrapper union : unions) {
2367                QueryWrapper queryWrapper = union.getQueryWrapper();
2368                paramValues = ArrayUtil.concat(paramValues, queryWrapper.getAllValueArray());
2369            }
2370        }
2371
2372        Object[] returnValues = withValues == null ? FlexConsts.EMPTY_ARRAY : withValues.toArray();
2373        returnValues = columnValues != null ? ArrayUtil.concat(returnValues, columnValues.toArray()) : returnValues;
2374        returnValues = tableValues != null ? ArrayUtil.concat(returnValues, tableValues.toArray()) : returnValues;
2375        returnValues = joinValues != null ? ArrayUtil.concat(returnValues, joinValues.toArray()) : returnValues;
2376        returnValues = ArrayUtil.concat(returnValues, paramValues);
2377
2378        return returnValues;
2379    }
2380
2381
2382    /**
2383     * 获取 queryWrapper 的参数
2384     * 在构建 sql 的时候，需要保证 where 在 having 的前面
2385     */
2386    Object[] getJoinValueArray() {
2387        // join 子查询的参数：left join (select ...)
2388        List<Object> joinValues = null;
2389        List<Join> joins = getJoins();
2390        if (CollectionUtil.isNotEmpty(joins)) {
2391            for (Join join : joins) {
2392                QueryTable joinTable = join.getQueryTable();
2393                Object[] valueArray = joinTable.getValueArray();
2394                if (valueArray.length > 0) {
2395                    if (joinValues == null) {
2396                        joinValues = new ArrayList<>(valueArray.length);
2397                    }
2398                    joinValues.addAll(Arrays.asList(valueArray));
2399                }
2400                QueryCondition onCondition = join.getOnCondition();
2401                Object[] values = WrapperUtil.getValues(onCondition);
2402                if (values.length > 0) {
2403                    if (joinValues == null) {
2404                        joinValues = new ArrayList<>(values.length);
2405                    }
2406                    joinValues.addAll(Arrays.asList(values));
2407                }
2408            }
2409        }
2410
2411        return joinValues == null ? FlexConsts.EMPTY_ARRAY : joinValues.toArray();
2412    }
2413
2414
2415    /**
2416     * 获取 queryWrapper 的参数
2417     * 在构建 sql 的时候，需要保证 where 在 having 的前面
2418     */
2419    Object[] getConditionValueArray() {
2420        // where 参数
2421        Object[] whereValues = WrapperUtil.getValues(whereQueryCondition);
2422
2423        // having 参数
2424        Object[] havingValues = WrapperUtil.getValues(havingQueryCondition);
2425
2426        Object[] paramValues = ArrayUtil.concat(whereValues, havingValues);
2427
2428        // unions 参数
2429        if (CollectionUtil.isNotEmpty(unions)) {
2430            for (UnionWrapper union : unions) {
2431                QueryWrapper queryWrapper = union.getQueryWrapper();
2432                paramValues = ArrayUtil.concat(paramValues, queryWrapper.getAllValueArray());
2433            }
2434        }
2435
2436        return paramValues;
2437    }
2438
2439
2440    List<QueryWrapper> getChildSelect() {
2441
2442        List<QueryWrapper> tableChildQuery = null;
2443        List<QueryTable> queryTables = getQueryTables();
2444        if (CollectionUtil.isNotEmpty(queryTables)) {
2445            for (QueryTable queryTable : queryTables) {
2446                if (queryTable instanceof SelectQueryTable) {
2447                    if (tableChildQuery == null) {
2448                        tableChildQuery = new ArrayList<>();
2449                    }
2450                    tableChildQuery.add(((SelectQueryTable) queryTable).getQueryWrapper());
2451                }
2452            }
2453        }
2454
2455        List<QueryWrapper> whereChildQuery = WrapperUtil.getChildQueryWrapper(whereQueryCondition);
2456        List<QueryWrapper> havingChildQuery = WrapperUtil.getChildQueryWrapper(havingQueryCondition);
2457
2458        if (tableChildQuery == null && whereChildQuery.isEmpty() && havingChildQuery.isEmpty()) {
2459            return Collections.emptyList();
2460        }
2461
2462        List<QueryWrapper> childQueryWrappers = tableChildQuery == null ? new ArrayList<>()
2463            : new ArrayList<>(tableChildQuery);
2464        childQueryWrappers.addAll(whereChildQuery);
2465        childQueryWrappers.addAll(havingChildQuery);
2466
2467        return childQueryWrappers;
2468    }
2469
2470    public String toSQL() {
2471        String sql = DialectFactory.getDialect().forSelectByQuery(this);
2472        return SqlUtil.replaceSqlParams(sql, getAllValueArray());
2473    }
2474
2475    @Override
2476    public QueryWrapper clone() {
2477        return super.clone();
2478    }
2479
2480}