源代码

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
018
019import com.mybatisflex.core.constant.SqlConsts;
020import com.mybatisflex.core.constant.SqlOperator;
021import com.mybatisflex.core.dialect.IDialect;
022import com.mybatisflex.core.exception.FlexExceptions;
023import com.mybatisflex.core.table.TableDef;
024import com.mybatisflex.core.util.*;
025
026import java.util.Collection;
027import java.util.List;
028import java.util.function.BiPredicate;
029import java.util.function.BooleanSupplier;
030import java.util.function.Predicate;
031
032/**
033 * 查询列，描述的是一张表的字段
034 */
035public class QueryColumn implements CloneSupport<QueryColumn>, Conditional<QueryCondition> {
036
037    protected QueryTable table;
038    protected String name;
039    protected String alias;
040
041    private boolean returnCopyByAsMethod = false;
042
043
044    public QueryColumn() {
045    }
046
047    public QueryColumn(String name) {
048        SqlUtil.keepColumnSafely(name);
049        this.name = StringUtil.tryTrim(name);
050    }
051
052    public QueryColumn(String tableName, String name) {
053        SqlUtil.keepColumnSafely(name);
054        this.table = new QueryTable(tableName);
055        this.name = StringUtil.tryTrim(name);
056    }
057
058    public QueryColumn(String schema, String tableName, String name) {
059        SqlUtil.keepColumnSafely(name);
060        this.table = new QueryTable(schema, tableName);
061        this.name = StringUtil.tryTrim(name);
062    }
063
064    public QueryColumn(String schema, String tableName, String name, String alias) {
065        SqlUtil.keepColumnSafely(name);
066        this.returnCopyByAsMethod = true;
067        this.table = new QueryTable(schema, tableName);
068        this.name = StringUtil.tryTrim(name);
069        this.alias = StringUtil.tryTrim(alias);
070    }
071
072    public QueryColumn(QueryTable queryTable, String name) {
073        SqlUtil.keepColumnSafely(name);
074        this.table = queryTable;
075        this.name = StringUtil.tryTrim(name);
076    }
077
078    public QueryColumn(TableDef tableDef, String name) {
079        this(tableDef, name, null);
080    }
081
082    public QueryColumn(TableDef tableDef, String name, String alias) {
083        SqlUtil.keepColumnSafely(name);
084        this.returnCopyByAsMethod = true;
085        this.table = new QueryTable(tableDef);
086        this.name = name;
087        this.alias = alias;
088    }
089
090
091    public QueryTable getTable() {
092        return table;
093    }
094
095    public void setTable(QueryTable table) {
096        this.table = table;
097    }
098
099    public String getName() {
100        return name;
101    }
102
103    public void setName(String name) {
104        this.name = name;
105    }
106
107    public String getAlias() {
108        return alias;
109    }
110
111    public void setAlias(String alias) {
112        this.alias = alias;
113    }
114
115    public <T> QueryColumn as(LambdaGetter<T> fn) {
116        return as(fn, false);
117    }
118
119    public <T> QueryColumn as(LambdaGetter<T> fn, boolean withPrefix) {
120        return as(LambdaUtil.getAliasName(fn, withPrefix));
121    }
122
123    public QueryColumn as(String alias) {
124        SqlUtil.keepColumnSafely(alias);
125        if (returnCopyByAsMethod) {
126            QueryColumn newColumn = new QueryColumn();
127            newColumn.table = this.table;
128            newColumn.name = this.name;
129            newColumn.alias = alias;
130            return newColumn;
131        } else {
132            this.alias = alias;
133            return this;
134        }
135    }
136
137
138    // query methods ///////
139
140    @Override
141    public QueryCondition eq(Object value) {
142        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
143            return QueryCondition.createEmpty();
144        }
145        return QueryCondition.create(this, SqlOperator.EQUALS, value);
146    }
147
148    @Override
149    public QueryCondition eq(Object value, boolean isEffective) {
150        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
151            return QueryCondition.createEmpty();
152        }
153        return QueryCondition.create(this, SqlOperator.EQUALS, value).when(isEffective);
154    }
155
156    @Override
157    public QueryCondition eq(Object value, BooleanSupplier isEffective) {
158        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
159            return QueryCondition.createEmpty();
160        }
161        return QueryCondition.create(this, SqlOperator.EQUALS, value).when(isEffective);
162    }
163
164    @Override
165    public <T> QueryCondition eq(T value, Predicate<T> isEffective) {
166        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
167            return QueryCondition.createEmpty();
168        }
169        return QueryCondition.create(this, SqlOperator.EQUALS, value).when(isEffective.test(value));
170    }
171
172    @Override
173    public QueryCondition ne(Object value) {
174        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
175            return QueryCondition.createEmpty();
176        }
177        return QueryCondition.create(this, SqlOperator.NOT_EQUALS, value);
178    }
179
180    @Override
181    public QueryCondition ne(Object value, boolean isEffective) {
182        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
183            return QueryCondition.createEmpty();
184        }
185        return QueryCondition.create(this, SqlOperator.NOT_EQUALS, value).when(isEffective);
186    }
187
188    @Override
189    public QueryCondition ne(Object value, BooleanSupplier isEffective) {
190        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
191            return QueryCondition.createEmpty();
192        }
193        return QueryCondition.create(this, SqlOperator.NOT_EQUALS, value).when(isEffective);
194    }
195
196    @Override
197    public <T> QueryCondition ne(T value, Predicate<T> isEffective) {
198        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
199            return QueryCondition.createEmpty();
200        }
201        return QueryCondition.create(this, SqlOperator.NOT_EQUALS, value).when(isEffective.test(value));
202    }
203
204    @Override
205    public QueryCondition gt(Object value) {
206        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
207            return QueryCondition.createEmpty();
208        }
209        return QueryCondition.create(this, SqlOperator.GT, value);
210    }
211
212    @Override
213    public QueryCondition gt(Object value, boolean isEffective) {
214        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
215            return QueryCondition.createEmpty();
216        }
217        return QueryCondition.create(this, SqlOperator.GT, value).when(isEffective);
218    }
219
220    @Override
221    public QueryCondition gt(Object value, BooleanSupplier isEffective) {
222        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
223            return QueryCondition.createEmpty();
224        }
225        return QueryCondition.create(this, SqlOperator.GT, value).when(isEffective);
226    }
227
228    @Override
229    public <T> QueryCondition gt(T value, Predicate<T> isEffective) {
230        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
231            return QueryCondition.createEmpty();
232        }
233        return QueryCondition.create(this, SqlOperator.GT, value).when(isEffective.test(value));
234    }
235
236    @Override
237    public QueryCondition ge(Object value) {
238        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
239            return QueryCondition.createEmpty();
240        }
241        return QueryCondition.create(this, SqlOperator.GE, value);
242    }
243
244    @Override
245    public QueryCondition ge(Object value, boolean isEffective) {
246        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
247            return QueryCondition.createEmpty();
248        }
249        return QueryCondition.create(this, SqlOperator.GE, value).when(isEffective);
250    }
251
252    @Override
253    public QueryCondition ge(Object value, BooleanSupplier isEffective) {
254        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
255            return QueryCondition.createEmpty();
256        }
257        return QueryCondition.create(this, SqlOperator.GE, value).when(isEffective);
258    }
259
260    @Override
261    public <T> QueryCondition ge(T value, Predicate<T> isEffective) {
262        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
263            return QueryCondition.createEmpty();
264        }
265        return QueryCondition.create(this, SqlOperator.GE, value).when(isEffective.test(value));
266    }
267
268    @Override
269    public QueryCondition lt(Object value) {
270        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
271            return QueryCondition.createEmpty();
272        }
273        return QueryCondition.create(this, SqlOperator.LT, value);
274    }
275
276    @Override
277    public QueryCondition lt(Object value, boolean isEffective) {
278        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
279            return QueryCondition.createEmpty();
280        }
281        return QueryCondition.create(this, SqlOperator.LT, value).when(isEffective);
282    }
283
284    @Override
285    public QueryCondition lt(Object value, BooleanSupplier isEffective) {
286        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
287            return QueryCondition.createEmpty();
288        }
289        return QueryCondition.create(this, SqlOperator.LT, value).when(isEffective);
290    }
291
292    @Override
293    public <T> QueryCondition lt(T value, Predicate<T> isEffective) {
294        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
295            return QueryCondition.createEmpty();
296        }
297        return QueryCondition.create(this, SqlOperator.LT, value).when(isEffective.test(value));
298    }
299
300    @Override
301    public QueryCondition le(Object value) {
302        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
303            return QueryCondition.createEmpty();
304        }
305        return QueryCondition.create(this, SqlOperator.LE, value);
306    }
307
308    @Override
309    public QueryCondition le(Object value, boolean isEffective) {
310        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
311            return QueryCondition.createEmpty();
312        }
313        return QueryCondition.create(this, SqlOperator.LE, value).when(isEffective);
314    }
315
316    @Override
317    public QueryCondition le(Object value, BooleanSupplier isEffective) {
318        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
319            return QueryCondition.createEmpty();
320        }
321        return QueryCondition.create(this, SqlOperator.LE, value).when(isEffective);
322    }
323
324    @Override
325    public <T> QueryCondition le(T value, Predicate<T> isEffective) {
326        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
327            return QueryCondition.createEmpty();
328        }
329        return QueryCondition.create(this, SqlOperator.LE, value).when(isEffective.test(value));
330    }
331
332    @Override
333    public QueryCondition in(Object... value) {
334        if (QueryColumnBehavior.shouldIgnoreValue(value) || value.length == 0) {
335            return QueryCondition.createEmpty();
336        }
337        // IN 里面只有一个值的情况
338        if (value.length == 1) {
339            if (QueryColumnBehavior.shouldIgnoreValue(value[0])) {
340                return QueryCondition.createEmpty();
341            }
342            if (QueryColumnBehavior.isSmartConvertInToEquals()) {
343                return QueryCondition.create(this, SqlOperator.EQUALS, value[0]);
344            }
345        }
346        return QueryCondition.create(this, SqlConsts.IN, value);
347    }
348
349    @Override
350    public QueryCondition in(Object[] value, boolean isEffective) {
351        if (QueryColumnBehavior.shouldIgnoreValue(value) || value.length == 0) {
352            return QueryCondition.createEmpty();
353        }
354        // IN 里面只有一个值的情况
355        if (value.length == 1) {
356            if (QueryColumnBehavior.shouldIgnoreValue(value[0])) {
357                return QueryCondition.createEmpty();
358            }
359            if (QueryColumnBehavior.isSmartConvertInToEquals()) {
360                return QueryCondition.create(this, SqlOperator.EQUALS, value[0]).when(isEffective);
361            }
362        }
363        return QueryCondition.create(this, SqlConsts.IN, value).when(isEffective);
364    }
365
366    @Override
367    public QueryCondition in(Object[] value, BooleanSupplier isEffective) {
368        if (QueryColumnBehavior.shouldIgnoreValue(value) || value.length == 0) {
369            return QueryCondition.createEmpty();
370        }
371        // IN 里面只有一个值的情况
372        if (value.length == 1) {
373            if (QueryColumnBehavior.shouldIgnoreValue(value[0])) {
374                return QueryCondition.createEmpty();
375            }
376            if (QueryColumnBehavior.isSmartConvertInToEquals()) {
377                return QueryCondition.create(this, SqlOperator.EQUALS, value[0]).when(isEffective);
378            }
379        }
380        return QueryCondition.create(this, SqlConsts.IN, value).when(isEffective);
381    }
382
383    @Override
384    public <T> QueryCondition in(T[] value, Predicate<T[]> isEffective) {
385        if (QueryColumnBehavior.shouldIgnoreValue(value) || value.length == 0) {
386            return QueryCondition.createEmpty();
387        }
388        // IN 里面只有一个值的情况
389        if (value.length == 1) {
390            if (QueryColumnBehavior.shouldIgnoreValue(value[0])) {
391                return QueryCondition.createEmpty();
392            }
393            if (QueryColumnBehavior.isSmartConvertInToEquals()) {
394                return QueryCondition.create(this, SqlOperator.EQUALS, value[0]).when(isEffective.test(value));
395            }
396        }
397        return QueryCondition.create(this, SqlConsts.IN, value).when(isEffective.test(value));
398    }
399
400    @Override
401    public QueryCondition in(Collection<?> value) {
402        if (value == null || value.isEmpty()) {
403            return QueryCondition.createEmpty();
404        }
405        return in(value.toArray());
406    }
407
408    @Override
409    public QueryCondition in(Collection<?> value, boolean isEffective) {
410        if (value == null || value.isEmpty()) {
411            return QueryCondition.createEmpty();
412        }
413        return in(value.toArray()).when(isEffective);
414    }
415
416    @Override
417    public QueryCondition in(Collection<?> value, BooleanSupplier isEffective) {
418        if (value == null || value.isEmpty()) {
419            return QueryCondition.createEmpty();
420        }
421        return in(value.toArray()).when(isEffective);
422    }
423
424    @Override
425    public <T extends Collection<?>> QueryCondition in(T value, Predicate<T> isEffective) {
426        if (value == null || value.isEmpty()) {
427            return QueryCondition.createEmpty();
428        }
429        return in(value.toArray()).when(isEffective.test(value));
430    }
431
432    @Override
433    public QueryCondition in(QueryWrapper queryWrapper) {
434        if (queryWrapper == null) {
435            return QueryCondition.createEmpty();
436        }
437        return QueryCondition.create(this, SqlOperator.IN, queryWrapper);
438    }
439
440    @Override
441    public QueryCondition in(QueryWrapper queryWrapper, boolean isEffective) {
442        if (queryWrapper == null) {
443            return QueryCondition.createEmpty();
444        }
445        return QueryCondition.create(this, SqlOperator.IN, queryWrapper).when(isEffective);
446    }
447
448    @Override
449    public QueryCondition in(QueryWrapper queryWrapper, BooleanSupplier isEffective) {
450        if (queryWrapper == null) {
451            return QueryCondition.createEmpty();
452        }
453        return QueryCondition.create(this, SqlOperator.IN, queryWrapper).when(isEffective);
454    }
455
456    @Override
457    public QueryCondition notIn(Object... value) {
458        if (QueryColumnBehavior.shouldIgnoreValue(value) || value.length == 0) {
459            return QueryCondition.createEmpty();
460        }
461        // NOT IN 里面只有一个值的情况
462        if (value.length == 1) {
463            if (QueryColumnBehavior.shouldIgnoreValue(value[0])) {
464                return QueryCondition.createEmpty();
465            }
466            if (QueryColumnBehavior.isSmartConvertInToEquals()) {
467                return QueryCondition.create(this, SqlOperator.NOT_EQUALS, value[0]);
468            }
469        }
470        return QueryCondition.create(this, SqlConsts.NOT_IN, value);
471    }
472
473    @Override
474    public QueryCondition notIn(Object[] value, boolean isEffective) {
475        if (QueryColumnBehavior.shouldIgnoreValue(value) || value.length == 0) {
476            return QueryCondition.createEmpty();
477        }
478        // NOT IN 里面只有一个值的情况
479        if (value.length == 1) {
480            if (QueryColumnBehavior.shouldIgnoreValue(value[0])) {
481                return QueryCondition.createEmpty();
482            }
483            if (QueryColumnBehavior.isSmartConvertInToEquals()) {
484                return QueryCondition.create(this, SqlOperator.NOT_EQUALS, value[0]).when(isEffective);
485            }
486        }
487        return QueryCondition.create(this, SqlConsts.NOT_IN, value).when(isEffective);
488    }
489
490    @Override
491    public QueryCondition notIn(Object[] value, BooleanSupplier isEffective) {
492        if (QueryColumnBehavior.shouldIgnoreValue(value) || value.length == 0) {
493            return QueryCondition.createEmpty();
494        }
495        // NOT IN 里面只有一个值的情况
496        if (value.length == 1) {
497            if (QueryColumnBehavior.shouldIgnoreValue(value[0])) {
498                return QueryCondition.createEmpty();
499            }
500            if (QueryColumnBehavior.isSmartConvertInToEquals()) {
501                return QueryCondition.create(this, SqlOperator.NOT_EQUALS, value[0]).when(isEffective);
502            }
503        }
504        return QueryCondition.create(this, SqlConsts.NOT_IN, value).when(isEffective);
505    }
506
507    @Override
508    public <T> QueryCondition notIn(T[] value, Predicate<T[]> isEffective) {
509        if (QueryColumnBehavior.shouldIgnoreValue(value) || value.length == 0) {
510            return QueryCondition.createEmpty();
511        }
512        // NOT IN 里面只有一个值的情况
513        if (value.length == 1) {
514            if (QueryColumnBehavior.shouldIgnoreValue(value[0])) {
515                return QueryCondition.createEmpty();
516            }
517            if (QueryColumnBehavior.isSmartConvertInToEquals()) {
518                return QueryCondition.create(this, SqlOperator.NOT_EQUALS, value[0]).when(isEffective.test(value));
519            }
520        }
521        return QueryCondition.create(this, SqlConsts.NOT_IN, value).when(isEffective.test(value));
522    }
523
524    @Override
525    public QueryCondition notIn(Collection<?> value) {
526        if (value == null || value.isEmpty()) {
527            return QueryCondition.createEmpty();
528        }
529        return notIn(value.toArray());
530    }
531
532    @Override
533    public QueryCondition notIn(Collection<?> value, boolean isEffective) {
534        if (value == null || value.isEmpty()) {
535            return QueryCondition.createEmpty();
536        }
537        return notIn(value.toArray()).when(isEffective);
538    }
539
540    @Override
541    public QueryCondition notIn(Collection<?> value, BooleanSupplier isEffective) {
542        if (value == null || value.isEmpty()) {
543            return QueryCondition.createEmpty();
544        }
545        return notIn(value.toArray()).when(isEffective);
546    }
547
548    @Override
549    public <T extends Collection<?>> QueryCondition notIn(T value, Predicate<T> isEffective) {
550        if (value == null || value.isEmpty()) {
551            return QueryCondition.createEmpty();
552        }
553        return notIn(value.toArray()).when(isEffective.test(value));
554    }
555
556    @Override
557    public QueryCondition notIn(QueryWrapper queryWrapper) {
558        if (queryWrapper == null) {
559            return QueryCondition.createEmpty();
560        }
561        return QueryCondition.create(this, SqlOperator.NOT_IN, queryWrapper);
562    }
563
564    @Override
565    public QueryCondition notIn(QueryWrapper queryWrapper, boolean isEffective) {
566        if (queryWrapper == null) {
567            return QueryCondition.createEmpty();
568        }
569        return QueryCondition.create(this, SqlOperator.NOT_IN, queryWrapper).when(isEffective);
570    }
571
572    @Override
573    public QueryCondition notIn(QueryWrapper queryWrapper, BooleanSupplier isEffective) {
574        if (queryWrapper == null) {
575            return QueryCondition.createEmpty();
576        }
577        return QueryCondition.create(this, SqlOperator.NOT_IN, queryWrapper).when(isEffective);
578    }
579
580    @Override
581    public QueryCondition between(Object start, Object end) {
582        if (QueryColumnBehavior.shouldIgnoreValue(start) || QueryColumnBehavior.shouldIgnoreValue(end)) {
583            return QueryCondition.createEmpty();
584        }
585        return QueryCondition.create(this, SqlOperator.BETWEEN, new Object[]{start, end});
586    }
587
588    @Override
589    public QueryCondition between(Object start, Object end, boolean isEffective) {
590        if (QueryColumnBehavior.shouldIgnoreValue(start) || QueryColumnBehavior.shouldIgnoreValue(end)) {
591            return QueryCondition.createEmpty();
592        }
593        return QueryCondition.create(this, SqlOperator.BETWEEN, new Object[]{start, end}).when(isEffective);
594    }
595
596    @Override
597    public QueryCondition between(Object start, Object end, BooleanSupplier isEffective) {
598        if (QueryColumnBehavior.shouldIgnoreValue(start) || QueryColumnBehavior.shouldIgnoreValue(end)) {
599            return QueryCondition.createEmpty();
600        }
601        return QueryCondition.create(this, SqlOperator.BETWEEN, new Object[]{start, end}).when(isEffective);
602    }
603
604    @Override
605    public <S, E> QueryCondition between(S start, E end, BiPredicate<S, E> isEffective) {
606        if (QueryColumnBehavior.shouldIgnoreValue(start) || QueryColumnBehavior.shouldIgnoreValue(end)) {
607            return QueryCondition.createEmpty();
608        }
609        return QueryCondition.create(this, SqlOperator.BETWEEN, new Object[]{start, end}).when(isEffective.test(start, end));
610    }
611
612    @Override
613    public QueryCondition notBetween(Object start, Object end) {
614        if (QueryColumnBehavior.shouldIgnoreValue(start) || QueryColumnBehavior.shouldIgnoreValue(end)) {
615            return QueryCondition.createEmpty();
616        }
617        return QueryCondition.create(this, SqlOperator.NOT_BETWEEN, new Object[]{start, end});
618    }
619
620    @Override
621    public QueryCondition notBetween(Object start, Object end, boolean isEffective) {
622        if (QueryColumnBehavior.shouldIgnoreValue(start) || QueryColumnBehavior.shouldIgnoreValue(end)) {
623            return QueryCondition.createEmpty();
624        }
625        return QueryCondition.create(this, SqlOperator.NOT_BETWEEN, new Object[]{start, end}).when(isEffective);
626    }
627
628    @Override
629    public QueryCondition notBetween(Object start, Object end, BooleanSupplier isEffective) {
630        if (QueryColumnBehavior.shouldIgnoreValue(start) || QueryColumnBehavior.shouldIgnoreValue(end)) {
631            return QueryCondition.createEmpty();
632        }
633        return QueryCondition.create(this, SqlOperator.NOT_BETWEEN, new Object[]{start, end}).when(isEffective);
634    }
635
636    @Override
637    public <S, E> QueryCondition notBetween(S start, E end, BiPredicate<S, E> isEffective) {
638        if (QueryColumnBehavior.shouldIgnoreValue(start) || QueryColumnBehavior.shouldIgnoreValue(end)) {
639            return QueryCondition.createEmpty();
640        }
641        return QueryCondition.create(this, SqlOperator.NOT_BETWEEN, new Object[]{start, end}).when(isEffective.test(start, end));
642    }
643
644    @Override
645    public QueryCondition like(Object value) {
646        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
647            return QueryCondition.createEmpty();
648        }
649        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value + "%");
650    }
651
652    @Override
653    public QueryCondition like(Object value, boolean isEffective) {
654        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
655            return QueryCondition.createEmpty();
656        }
657        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value + "%").when(isEffective);
658    }
659
660    @Override
661    public QueryCondition like(Object value, BooleanSupplier isEffective) {
662        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
663            return QueryCondition.createEmpty();
664        }
665        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value + "%").when(isEffective);
666    }
667
668    @Override
669    public <T> QueryCondition like(T value, Predicate<T> isEffective) {
670        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
671            return QueryCondition.createEmpty();
672        }
673        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value + "%").when(isEffective.test(value));
674    }
675
676    @Override
677    public QueryCondition likeLeft(Object value) {
678        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
679            return QueryCondition.createEmpty();
680        }
681        return QueryCondition.create(this, SqlOperator.LIKE, value + "%");
682    }
683
684    @Override
685    public QueryCondition likeLeft(Object value, boolean isEffective) {
686        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
687            return QueryCondition.createEmpty();
688        }
689        return QueryCondition.create(this, SqlOperator.LIKE, value + "%").when(isEffective);
690    }
691
692    @Override
693    public QueryCondition likeLeft(Object value, BooleanSupplier isEffective) {
694        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
695            return QueryCondition.createEmpty();
696        }
697        return QueryCondition.create(this, SqlOperator.LIKE, value + "%").when(isEffective);
698    }
699
700    @Override
701    public <T> QueryCondition likeLeft(T value, Predicate<T> isEffective) {
702        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
703            return QueryCondition.createEmpty();
704        }
705        return QueryCondition.create(this, SqlOperator.LIKE, value + "%").when(isEffective.test(value));
706    }
707
708    @Override
709    public QueryCondition likeRight(Object value) {
710        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
711            return QueryCondition.createEmpty();
712        }
713        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value);
714    }
715
716    @Override
717    public QueryCondition likeRight(Object value, boolean isEffective) {
718        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
719            return QueryCondition.createEmpty();
720        }
721        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value).when(isEffective);
722    }
723
724    @Override
725    public QueryCondition likeRight(Object value, BooleanSupplier isEffective) {
726        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
727            return QueryCondition.createEmpty();
728        }
729        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value).when(isEffective);
730    }
731
732    @Override
733    public <T> QueryCondition likeRight(T value, Predicate<T> isEffective) {
734        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
735            return QueryCondition.createEmpty();
736        }
737        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value).when(isEffective.test(value));
738    }
739
740    /**
741     * {@code LIKE value}
742     */
743    public QueryCondition likeRaw(Object value) {
744        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
745            return QueryCondition.createEmpty();
746        }
747        return likeRaw(value, true);
748    }
749
750    /**
751     * {@code LIKE value}
752     */
753    public QueryCondition likeRaw(Object value, boolean isEffective) {
754        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
755            return QueryCondition.createEmpty();
756        }
757        return QueryCondition.create(this, SqlOperator.LIKE, value).when(isEffective);
758    }
759
760    /**
761     * {@code LIKE value}
762     */
763    public QueryCondition likeRaw(Object value, BooleanSupplier isEffective) {
764        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
765            return QueryCondition.createEmpty();
766        }
767        return likeRaw(value, isEffective.getAsBoolean());
768    }
769
770    /**
771     * {@code LIKE value}
772     */
773    public <T> QueryCondition likeRaw(T value, Predicate<T> isEffective) {
774        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
775            return QueryCondition.createEmpty();
776        }
777        return likeRaw(value, isEffective.test(value));
778    }
779
780    @Override
781    public QueryCondition notLike(Object value) {
782        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
783            return QueryCondition.createEmpty();
784        }
785        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value + "%");
786    }
787
788    @Override
789    public QueryCondition notLike(Object value, boolean isEffective) {
790        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
791            return QueryCondition.createEmpty();
792        }
793        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value + "%").when(isEffective);
794    }
795
796    @Override
797    public QueryCondition notLike(Object value, BooleanSupplier isEffective) {
798        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
799            return QueryCondition.createEmpty();
800        }
801        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value + "%").when(isEffective);
802    }
803
804    @Override
805    public <T> QueryCondition notLike(T value, Predicate<T> isEffective) {
806        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
807            return QueryCondition.createEmpty();
808        }
809        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value + "%").when(isEffective.test(value));
810    }
811
812    @Override
813    public QueryCondition notLikeLeft(Object value) {
814        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
815            return QueryCondition.createEmpty();
816        }
817        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value + "%");
818    }
819
820    @Override
821    public QueryCondition notLikeLeft(Object value, boolean isEffective) {
822        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
823            return QueryCondition.createEmpty();
824        }
825        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value + "%").when(isEffective);
826    }
827
828    @Override
829    public QueryCondition notLikeLeft(Object value, BooleanSupplier isEffective) {
830        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
831            return QueryCondition.createEmpty();
832        }
833        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value + "%").when(isEffective);
834    }
835
836    @Override
837    public <T> QueryCondition notLikeLeft(T value, Predicate<T> isEffective) {
838        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
839            return QueryCondition.createEmpty();
840        }
841        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value + "%").when(isEffective.test(value));
842    }
843
844    @Override
845    public QueryCondition notLikeRight(Object value) {
846        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
847            return QueryCondition.createEmpty();
848        }
849        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value);
850    }
851
852    @Override
853    public QueryCondition notLikeRight(Object value, boolean isEffective) {
854        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
855            return QueryCondition.createEmpty();
856        }
857        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value).when(isEffective);
858    }
859
860    @Override
861    public QueryCondition notLikeRight(Object value, BooleanSupplier isEffective) {
862        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
863            return QueryCondition.createEmpty();
864        }
865        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value).when(isEffective);
866    }
867
868    @Override
869    public <T> QueryCondition notLikeRight(T value, Predicate<T> isEffective) {
870        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
871            return QueryCondition.createEmpty();
872        }
873        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value).when(isEffective.test(value));
874    }
875
876    /**
877     * {@code NOT LIKE value}
878     */
879    public QueryCondition notLikeRaw(Object value) {
880        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
881            return QueryCondition.createEmpty();
882        }
883        return likeRaw(value, true);
884    }
885
886    /**
887     * {@code NOT LIKE value}
888     */
889    public QueryCondition notLikeRaw(Object value, boolean isEffective) {
890        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
891            return QueryCondition.createEmpty();
892        }
893        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value).when(isEffective);
894    }
895
896    /**
897     * {@code NOT LIKE value}
898     */
899    public QueryCondition notLikeRaw(Object value, BooleanSupplier isEffective) {
900        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
901            return QueryCondition.createEmpty();
902        }
903        return likeRaw(value, isEffective.getAsBoolean());
904    }
905
906    /**
907     * {@code NOT LIKE value}
908     */
909    public <T> QueryCondition notLikeRaw(T value, Predicate<T> isEffective) {
910        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
911            return QueryCondition.createEmpty();
912        }
913        return likeRaw(value, isEffective.test(value));
914    }
915
916    @Override
917    public QueryCondition isNull(boolean isEffective) {
918        return QueryCondition.create(this, SqlOperator.IS_NULL, null).when(isEffective);
919    }
920
921    @Override
922    public QueryCondition isNotNull(boolean isEffective) {
923        return QueryCondition.create(this, SqlOperator.IS_NOT_NULL, null).when(isEffective);
924    }
925
926
927    ////order by ////
928    public QueryOrderBy asc() {
929        return new QueryOrderBy(this, SqlConsts.ASC);
930    }
931
932
933    public QueryOrderBy desc() {
934        return new QueryOrderBy(this, SqlConsts.DESC);
935    }
936
937
938    // 运算 加减乘除 + - * /
939    public QueryColumn add(QueryColumn queryColumn) {
940        return new ArithmeticQueryColumn(this).add(queryColumn);
941    }
942
943    public QueryColumn add(Number number) {
944        return new ArithmeticQueryColumn(this).add(number);
945    }
946
947    public QueryColumn subtract(QueryColumn queryColumn) {
948        return new ArithmeticQueryColumn(this).subtract(queryColumn);
949    }
950
951    public QueryColumn subtract(Number number) {
952        return new ArithmeticQueryColumn(this).subtract(number);
953    }
954
955    public QueryColumn multiply(QueryColumn queryColumn) {
956        return new ArithmeticQueryColumn(this).multiply(queryColumn);
957    }
958
959    public QueryColumn multiply(Number number) {
960        return new ArithmeticQueryColumn(this).multiply(number);
961    }
962
963    public QueryColumn divide(QueryColumn queryColumn) {
964        return new ArithmeticQueryColumn(this).divide(queryColumn);
965    }
966
967    public QueryColumn divide(Number number) {
968        return new ArithmeticQueryColumn(this).divide(number);
969    }
970
971
972    String toConditionSql(List<QueryTable> queryTables, IDialect dialect) {
973        QueryTable selectTable = getSelectTable(queryTables, table);
974        if (selectTable == null) {
975            return dialect.wrap(name);
976        } else {
977            if (StringUtil.isNotBlank(selectTable.alias)) {
978                return dialect.wrap(selectTable.alias) + SqlConsts.REFERENCE + dialect.wrap(name);
979            } else if (StringUtil.isNotBlank(selectTable.getSchema()) && StringUtil.isNotBlank(selectTable.getName())) {
980                String realTable = dialect.getRealTable(selectTable.getName());
981                return dialect.wrap(dialect.getRealSchema(selectTable.schema, realTable)) + SqlConsts.REFERENCE + dialect.wrap(realTable)
982                    + SqlConsts.REFERENCE + dialect.wrap(name);
983            } else if (StringUtil.isNotBlank(selectTable.getName())) {
984                return dialect.wrap(dialect.getRealTable(selectTable.getName())) + SqlConsts.REFERENCE + dialect.wrap(name);
985            } else {
986                return dialect.wrap(name);
987            }
988        }
989    }
990
991
992    String toSelectSql(List<QueryTable> queryTables, IDialect dialect) {
993        return toConditionSql(queryTables, dialect) + WrapperUtil.buildColumnAlias(alias, dialect);
994    }
995
996
997    QueryTable getSelectTable(List<QueryTable> queryTables, QueryTable selfTable) {
998        //未查询任何表
999        if (queryTables == null || queryTables.isEmpty()) {
1000            return null;
1001        }
1002
1003        if (selfTable != null && StringUtil.isNotBlank(selfTable.alias)) {
1004            return selfTable;
1005        }
1006
1007        if (queryTables.size() == 1 && queryTables.get(0).isSameTable(selfTable)) {
1008            //ignore table
1009            return null;
1010        }
1011
1012        if (CollectionUtil.isEmpty(queryTables)) {
1013            return selfTable;
1014        }
1015
1016        if (selfTable == null && queryTables.size() == 1) {
1017            return queryTables.get(0);
1018        }
1019
1020        for (QueryTable table : queryTables) {
1021            if (table.isSameTable(selfTable)) {
1022                return table;
1023            }
1024        }
1025        return selfTable;
1026    }
1027
1028
1029    @Override
1030    public String toString() {
1031        return "QueryColumn{" +
1032            "table=" + table +
1033            ", name='" + name + '\'' +
1034            ", alias='" + alias + '\'' +
1035            '}';
1036    }
1037
1038
1039    @Override
1040    public QueryColumn clone() {
1041        try {
1042            QueryColumn clone = (QueryColumn) super.clone();
1043            // deep clone ...
1044            clone.table = ObjectUtil.clone(this.table);
1045            return clone;
1046        } catch (CloneNotSupportedException e) {
1047            throw FlexExceptions.wrap(e);
1048        }
1049    }
1050
1051}