源代码

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) {
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) {
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) {
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) {
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) {
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) {
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) {
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) {
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        return QueryCondition.create(this, SqlOperator.BETWEEN, new Object[]{start, end});
583    }
584
585    @Override
586    public QueryCondition between(Object start, Object end, boolean isEffective) {
587        return QueryCondition.create(this, SqlOperator.BETWEEN, new Object[]{start, end}).when(isEffective);
588    }
589
590    @Override
591    public QueryCondition between(Object start, Object end, BooleanSupplier isEffective) {
592        return QueryCondition.create(this, SqlOperator.BETWEEN, new Object[]{start, end}).when(isEffective);
593    }
594
595    @Override
596    public <S, E> QueryCondition between(S start, E end, BiPredicate<S, E> isEffective) {
597        return QueryCondition.create(this, SqlOperator.BETWEEN, new Object[]{start, end}).when(isEffective.test(start, end));
598    }
599
600    @Override
601    public QueryCondition notBetween(Object start, Object end) {
602        return QueryCondition.create(this, SqlOperator.NOT_BETWEEN, new Object[]{start, end});
603    }
604
605    @Override
606    public QueryCondition notBetween(Object start, Object end, boolean isEffective) {
607        return QueryCondition.create(this, SqlOperator.NOT_BETWEEN, new Object[]{start, end}).when(isEffective);
608    }
609
610    @Override
611    public QueryCondition notBetween(Object start, Object end, BooleanSupplier isEffective) {
612        return QueryCondition.create(this, SqlOperator.NOT_BETWEEN, new Object[]{start, end}).when(isEffective);
613    }
614
615    @Override
616    public <S, E> QueryCondition notBetween(S start, E end, BiPredicate<S, E> isEffective) {
617        return QueryCondition.create(this, SqlOperator.NOT_BETWEEN, new Object[]{start, end}).when(isEffective.test(start, end));
618    }
619
620    @Override
621    public QueryCondition like(Object value) {
622        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
623            return QueryCondition.createEmpty();
624        }
625        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value + "%");
626    }
627
628    @Override
629    public QueryCondition like(Object value, boolean isEffective) {
630        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
631            return QueryCondition.createEmpty();
632        }
633        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value + "%").when(isEffective);
634    }
635
636    @Override
637    public QueryCondition like(Object value, BooleanSupplier isEffective) {
638        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
639            return QueryCondition.createEmpty();
640        }
641        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value + "%").when(isEffective);
642    }
643
644    @Override
645    public <T> QueryCondition like(T value, Predicate<T> isEffective) {
646        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
647            return QueryCondition.createEmpty();
648        }
649        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value + "%").when(isEffective.test(value));
650    }
651
652    @Override
653    public QueryCondition likeLeft(Object value) {
654        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
655            return QueryCondition.createEmpty();
656        }
657        return QueryCondition.create(this, SqlOperator.LIKE, value + "%");
658    }
659
660    @Override
661    public QueryCondition likeLeft(Object value, boolean 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 QueryCondition likeLeft(Object value, BooleanSupplier isEffective) {
670        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
671            return QueryCondition.createEmpty();
672        }
673        return QueryCondition.create(this, SqlOperator.LIKE, value + "%").when(isEffective);
674    }
675
676    @Override
677    public <T> QueryCondition likeLeft(T value, Predicate<T> isEffective) {
678        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
679            return QueryCondition.createEmpty();
680        }
681        return QueryCondition.create(this, SqlOperator.LIKE, value + "%").when(isEffective.test(value));
682    }
683
684    @Override
685    public QueryCondition likeRight(Object value) {
686        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
687            return QueryCondition.createEmpty();
688        }
689        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value);
690    }
691
692    @Override
693    public QueryCondition likeRight(Object value, boolean 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 QueryCondition likeRight(Object value, BooleanSupplier isEffective) {
702        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
703            return QueryCondition.createEmpty();
704        }
705        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value).when(isEffective);
706    }
707
708    @Override
709    public <T> QueryCondition likeRight(T value, Predicate<T> isEffective) {
710        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
711            return QueryCondition.createEmpty();
712        }
713        return QueryCondition.create(this, SqlOperator.LIKE, "%" + value).when(isEffective.test(value));
714    }
715
716    /**
717     * {@code LIKE value}
718     */
719    public QueryCondition likeRaw(Object value) {
720        return likeRaw(value, true);
721    }
722
723    /**
724     * {@code LIKE value}
725     */
726    public QueryCondition likeRaw(Object value, boolean isEffective) {
727        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
728            return QueryCondition.createEmpty();
729        }
730        return QueryCondition.create(this, SqlOperator.LIKE, value).when(isEffective);
731    }
732
733    /**
734     * {@code LIKE value}
735     */
736    public QueryCondition likeRaw(Object value, BooleanSupplier isEffective) {
737        return likeRaw(value, isEffective.getAsBoolean());
738    }
739
740    /**
741     * {@code LIKE value}
742     */
743    public <T> QueryCondition likeRaw(T value, Predicate<T> isEffective) {
744        return likeRaw(value, isEffective.test(value));
745    }
746
747    @Override
748    public QueryCondition notLike(Object value) {
749        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
750            return QueryCondition.createEmpty();
751        }
752        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value + "%");
753    }
754
755    @Override
756    public QueryCondition notLike(Object value, boolean isEffective) {
757        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
758            return QueryCondition.createEmpty();
759        }
760        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value + "%").when(isEffective);
761    }
762
763    @Override
764    public QueryCondition notLike(Object value, BooleanSupplier isEffective) {
765        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
766            return QueryCondition.createEmpty();
767        }
768        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value + "%").when(isEffective);
769    }
770
771    @Override
772    public <T> QueryCondition notLike(T value, Predicate<T> isEffective) {
773        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
774            return QueryCondition.createEmpty();
775        }
776        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value + "%").when(isEffective.test(value));
777    }
778
779    @Override
780    public QueryCondition notLikeLeft(Object value) {
781        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
782            return QueryCondition.createEmpty();
783        }
784        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value + "%");
785    }
786
787    @Override
788    public QueryCondition notLikeLeft(Object value, boolean isEffective) {
789        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
790            return QueryCondition.createEmpty();
791        }
792        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value + "%").when(isEffective);
793    }
794
795    @Override
796    public QueryCondition notLikeLeft(Object value, BooleanSupplier isEffective) {
797        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
798            return QueryCondition.createEmpty();
799        }
800        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value + "%").when(isEffective);
801    }
802
803    @Override
804    public <T> QueryCondition notLikeLeft(T value, Predicate<T> isEffective) {
805        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
806            return QueryCondition.createEmpty();
807        }
808        return QueryCondition.create(this, SqlOperator.NOT_LIKE, value + "%").when(isEffective.test(value));
809    }
810
811    @Override
812    public QueryCondition notLikeRight(Object value) {
813        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
814            return QueryCondition.createEmpty();
815        }
816        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value);
817    }
818
819    @Override
820    public QueryCondition notLikeRight(Object value, boolean isEffective) {
821        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
822            return QueryCondition.createEmpty();
823        }
824        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value).when(isEffective);
825    }
826
827    @Override
828    public QueryCondition notLikeRight(Object value, BooleanSupplier isEffective) {
829        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
830            return QueryCondition.createEmpty();
831        }
832        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value).when(isEffective);
833    }
834
835    @Override
836    public <T> QueryCondition notLikeRight(T value, Predicate<T> isEffective) {
837        if (QueryColumnBehavior.shouldIgnoreValue(value)) {
838            return QueryCondition.createEmpty();
839        }
840        return QueryCondition.create(this, SqlOperator.NOT_LIKE, "%" + value).when(isEffective.test(value));
841    }
842
843    /**
844     * {@code NOT LIKE value}
845     */
846    public QueryCondition notLikeRaw(Object value) {
847        return likeRaw(value, true);
848    }
849
850    /**
851     * {@code NOT LIKE value}
852     */
853    public QueryCondition notLikeRaw(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    /**
861     * {@code NOT LIKE value}
862     */
863    public QueryCondition notLikeRaw(Object value, BooleanSupplier isEffective) {
864        return likeRaw(value, isEffective.getAsBoolean());
865    }
866
867    /**
868     * {@code NOT LIKE value}
869     */
870    public <T> QueryCondition notLikeRaw(T value, Predicate<T> isEffective) {
871        return likeRaw(value, isEffective.test(value));
872    }
873
874    @Override
875    public QueryCondition isNull(boolean isEffective) {
876        return QueryCondition.create(this, SqlOperator.IS_NULL, null).when(isEffective);
877    }
878
879    @Override
880    public QueryCondition isNotNull(boolean isEffective) {
881        return QueryCondition.create(this, SqlOperator.IS_NOT_NULL, null).when(isEffective);
882    }
883
884
885    ////order by ////
886    public QueryOrderBy asc() {
887        return new QueryOrderBy(this, SqlConsts.ASC);
888    }
889
890
891    public QueryOrderBy desc() {
892        return new QueryOrderBy(this, SqlConsts.DESC);
893    }
894
895
896    // 运算 加减乘除 + - * /
897    public QueryColumn add(QueryColumn queryColumn) {
898        return new ArithmeticQueryColumn(this).add(queryColumn);
899    }
900
901    public QueryColumn add(Number number) {
902        return new ArithmeticQueryColumn(this).add(number);
903    }
904
905    public QueryColumn subtract(QueryColumn queryColumn) {
906        return new ArithmeticQueryColumn(this).subtract(queryColumn);
907    }
908
909    public QueryColumn subtract(Number number) {
910        return new ArithmeticQueryColumn(this).subtract(number);
911    }
912
913    public QueryColumn multiply(QueryColumn queryColumn) {
914        return new ArithmeticQueryColumn(this).multiply(queryColumn);
915    }
916
917    public QueryColumn multiply(Number number) {
918        return new ArithmeticQueryColumn(this).multiply(number);
919    }
920
921    public QueryColumn divide(QueryColumn queryColumn) {
922        return new ArithmeticQueryColumn(this).divide(queryColumn);
923    }
924
925    public QueryColumn divide(Number number) {
926        return new ArithmeticQueryColumn(this).divide(number);
927    }
928
929
930    String toConditionSql(List<QueryTable> queryTables, IDialect dialect) {
931        QueryTable selectTable = getSelectTable(queryTables, table);
932        if (selectTable == null) {
933            return dialect.wrap(name);
934        } else {
935            if (StringUtil.isNotBlank(selectTable.alias)) {
936                return dialect.wrap(selectTable.alias) + SqlConsts.REFERENCE + dialect.wrap(name);
937            } else if (StringUtil.isNotBlank(selectTable.getSchema()) && StringUtil.isNotBlank(selectTable.getName())) {
938                return dialect.wrap(dialect.getRealSchema(selectTable.schema)) + SqlConsts.REFERENCE + dialect.wrap(dialect.getRealTable(selectTable.getName())) + SqlConsts.REFERENCE + dialect.wrap(name);
939            } else if (StringUtil.isNotBlank(selectTable.getName())) {
940                return dialect.wrap(dialect.getRealTable(selectTable.getName())) + SqlConsts.REFERENCE + dialect.wrap(name);
941            } else {
942                return dialect.wrap(name);
943            }
944        }
945    }
946
947
948    String toSelectSql(List<QueryTable> queryTables, IDialect dialect) {
949        return toConditionSql(queryTables, dialect) + WrapperUtil.buildAlias(alias, dialect);
950    }
951
952
953    QueryTable getSelectTable(List<QueryTable> queryTables, QueryTable selfTable) {
954        //未查询任何表
955        if (queryTables == null || queryTables.isEmpty()) {
956            return null;
957        }
958
959        if (selfTable != null && StringUtil.isNotBlank(selfTable.alias)) {
960            return selfTable;
961        }
962
963        if (queryTables.size() == 1 && queryTables.get(0).isSameTable(selfTable)) {
964            //ignore table
965            return null;
966        }
967
968        if (CollectionUtil.isEmpty(queryTables)) {
969            return selfTable;
970        }
971
972        if (selfTable == null && queryTables.size() == 1) {
973            return queryTables.get(0);
974        }
975
976        for (QueryTable table : queryTables) {
977            if (table.isSameTable(selfTable)) {
978                return table;
979            }
980        }
981        return selfTable;
982    }
983
984
985    @Override
986    public String toString() {
987        return "QueryColumn{" +
988            "table=" + table +
989            ", name='" + name + '\'' +
990            ", alias='" + alias + '\'' +
991            '}';
992    }
993
994
995    @Override
996    public QueryColumn clone() {
997        try {
998            QueryColumn clone = (QueryColumn) super.clone();
999            // deep clone ...
1000            clone.table = ObjectUtil.clone(this.table);
1001            return clone;
1002        } catch (CloneNotSupportedException e) {
1003            throw FlexExceptions.wrap(e);
1004        }
1005    }
1006
1007}