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.table.TableInfo;
019import com.mybatisflex.core.table.TableInfoFactory;
020import com.mybatisflex.core.util.ArrayUtil;
021import com.mybatisflex.core.util.LambdaGetter;
022import com.mybatisflex.core.util.LambdaUtil;
023
024import java.util.ArrayList;
025import java.util.List;
026
027import static com.mybatisflex.core.constant.FuncName.*;
028
029/**
030 * SQL 函数。
031 */
032@SuppressWarnings("unused")
033public class QueryMethods {
034
035    private QueryMethods() {
036    }
037
038    // === 数学函数 ===
039
040    /**
041     * 返回 x 的绝对值。
042     */
043    public static QueryColumn abs(String columnX) {
044        return new FunctionQueryColumn(ABS, columnX);
045    }
046
047    /**
048     * 返回 x 的绝对值。
049     */
050    public static QueryColumn abs(QueryColumn columnX) {
051        return new FunctionQueryColumn(ABS, columnX);
052    }
053
054    /**
055     * 返回 x 的绝对值。
056     */
057    public static <T> QueryColumn abs(LambdaGetter<T> columnX) {
058        return new FunctionQueryColumn(ABS, LambdaUtil.getQueryColumn(columnX));
059    }
060
061    /**
062     * 返回大于或等于 x 的最小整数（向上取整）。
063     */
064    public static QueryColumn ceil(String columnX) {
065        return new FunctionQueryColumn(CEIL, columnX);
066    }
067
068    /**
069     * 返回大于或等于 x 的最小整数（向上取整）。
070     */
071    public static QueryColumn ceil(QueryColumn columnX) {
072        return new FunctionQueryColumn(CEIL, columnX);
073    }
074
075    /**
076     * 返回大于或等于 x 的最小整数（向上取整）。
077     */
078    public static <T> QueryColumn ceil(LambdaGetter<T> columnX) {
079        return new FunctionQueryColumn(CEIL, LambdaUtil.getQueryColumn(columnX));
080    }
081
082    /**
083     * 返回大于或等于 x 的最小整数（向上取整）。
084     */
085    public static QueryColumn ceiling(String columnX) {
086        return new FunctionQueryColumn(CEILING, columnX);
087    }
088
089    /**
090     * 返回大于或等于 x 的最小整数（向上取整）。
091     */
092    public static QueryColumn ceiling(QueryColumn columnX) {
093        return new FunctionQueryColumn(CEILING, columnX);
094    }
095
096    /**
097     * 返回大于或等于 x 的最小整数（向上取整）。
098     */
099    public static <T> QueryColumn ceiling(LambdaGetter<T> columnX) {
100        return new FunctionQueryColumn(CEILING, LambdaUtil.getQueryColumn(columnX));
101    }
102
103    /**
104     * 返回小于或等于 x 的最大整数（向下取整）。
105     */
106    public static QueryColumn floor(String columnX) {
107        return new FunctionQueryColumn(FLOOR, columnX);
108    }
109
110    /**
111     * 返回小于或等于 x 的最大整数（向下取整）。
112     */
113    public static QueryColumn floor(QueryColumn columnX) {
114        return new FunctionQueryColumn(FLOOR, columnX);
115    }
116
117    /**
118     * 返回小于或等于 x 的最大整数（向下取整）。
119     */
120    public static <T> QueryColumn floor(LambdaGetter<T> columnX) {
121        return new FunctionQueryColumn(FLOOR, LambdaUtil.getQueryColumn(columnX));
122    }
123
124    /**
125     * 返回 0~1 的随机数。
126     */
127    public static QueryColumn rand() {
128        return new FunctionQueryColumn(RAND);
129    }
130
131    /**
132     * 返回 0~1 的随机数，x 值相同时返回的随机数相同。
133     */
134    public static QueryColumn rand(String columnX) {
135        return new FunctionQueryColumn(RAND, columnX);
136    }
137
138    /**
139     * 返回 0~1 的随机数，x 值相同时返回的随机数相同。
140     */
141    public static QueryColumn rand(QueryColumn columnX) {
142        return new FunctionQueryColumn(RAND, columnX);
143    }
144
145    /**
146     * 返回 0~1 的随机数，x 值相同时返回的随机数相同。
147     */
148    public static <T> QueryColumn rand(LambdaGetter<T> columnX) {
149        return new FunctionQueryColumn(RAND, LambdaUtil.getQueryColumn(columnX));
150    }
151
152    /**
153     * 返回 x 的符号，x 是负数、0、正数分别返回 -1、0、1。
154     */
155    public static QueryColumn sign(String columnX) {
156        return new FunctionQueryColumn(SIGN, columnX);
157    }
158
159    /**
160     * 返回 x 的符号，x 是负数、0、正数分别返回 -1、0、1。
161     */
162    public static QueryColumn sign(QueryColumn columnX) {
163        return new FunctionQueryColumn(SIGN, columnX);
164    }
165
166    /**
167     * 返回 x 的符号，x 是负数、0、正数分别返回 -1、0、1。
168     */
169    public static <T> QueryColumn sign(LambdaGetter<T> columnX) {
170        return new FunctionQueryColumn(SIGN, LambdaUtil.getQueryColumn(columnX));
171    }
172
173    /**
174     * 返回圆周率。
175     */
176    public static QueryColumn pi() {
177        return new FunctionQueryColumn(PI);
178    }
179
180    /**
181     * 返回数值 x 保留到小数点后 y 位的值。
182     */
183    public static QueryColumn truncate(String columnX, String columnY) {
184        return new FunctionQueryColumn(TRUNCATE, columnX, columnY);
185    }
186
187    /**
188     * 返回数值 x 保留到小数点后 y 位的值。
189     */
190    public static QueryColumn truncate(QueryColumn columnX, QueryColumn columnY) {
191        return new FunctionQueryColumn(TRUNCATE, columnX, columnY);
192    }
193
194    /**
195     * 返回数值 x 保留到小数点后 y 位的值。
196     */
197    public static <X, Y> QueryColumn truncate(LambdaGetter<X> columnX, LambdaGetter<Y> columnY) {
198        return new FunctionQueryColumn(TRUNCATE, LambdaUtil.getQueryColumn(columnX), LambdaUtil.getQueryColumn(columnY));
199    }
200
201    /**
202     * 返回数值 x 保留到小数点后 y 位的值。
203     */
204    public static QueryColumn truncate(String columnX, Integer y) {
205        return new FunctionQueryColumn(TRUNCATE, new QueryColumn(columnX), number(y));
206    }
207
208    /**
209     * 返回数值 x 保留到小数点后 y 位的值。
210     */
211    public static QueryColumn truncate(QueryColumn columnX, Integer y) {
212        return new FunctionQueryColumn(TRUNCATE, columnX, number(y));
213    }
214
215    /**
216     * 返回数值 x 保留到小数点后 y 位的值。
217     */
218    public static <T> QueryColumn truncate(LambdaGetter<T> columnX, Integer y) {
219        return new FunctionQueryColumn(TRUNCATE, LambdaUtil.getQueryColumn(columnX), number(y));
220    }
221
222    /**
223     * 返回离 x 最近的整数（四舍五入）。
224     */
225    public static QueryColumn round(String columnX) {
226        return new FunctionQueryColumn(ROUND, columnX);
227    }
228
229    /**
230     * 返回离 x 最近的整数（四舍五入）。
231     */
232    public static QueryColumn round(QueryColumn columnX) {
233        return new FunctionQueryColumn(ROUND, columnX);
234    }
235
236    /**
237     * 返回离 x 最近的整数（四舍五入）。
238     */
239    public static <T> QueryColumn round(LambdaGetter<T> columnX) {
240        return new FunctionQueryColumn(ROUND, LambdaUtil.getQueryColumn(columnX));
241    }
242
243    /**
244     * 保留 x 小数点后 y 位的值，但截断时要四舍五入。
245     */
246    public static QueryColumn round(String columnX, String columnY) {
247        return new FunctionQueryColumn(ROUND, columnX, columnY);
248    }
249
250    /**
251     * 保留 x 小数点后 y 位的值，但截断时要四舍五入。
252     */
253    public static QueryColumn round(QueryColumn columnX, QueryColumn columnY) {
254        return new FunctionQueryColumn(ROUND, columnX, columnY);
255    }
256
257    /**
258     * 保留 x 小数点后 y 位的值，但截断时要四舍五入。
259     */
260    public static <X, Y> QueryColumn round(LambdaGetter<X> columnX, LambdaGetter<Y> columnY) {
261        return new FunctionQueryColumn(ROUND, LambdaUtil.getQueryColumn(columnX), LambdaUtil.getQueryColumn(columnY));
262    }
263
264    /**
265     * 保留 x 小数点后 y 位的值，但截断时要四舍五入。
266     */
267    public static QueryColumn round(String columnX, Integer y) {
268        return new FunctionQueryColumn(ROUND, new QueryColumn(columnX), number(y));
269    }
270
271    /**
272     * 保留 x 小数点后 y 位的值，但截断时要四舍五入。
273     */
274    public static QueryColumn round(QueryColumn columnX, Integer y) {
275        return new FunctionQueryColumn(ROUND, columnX, number(y));
276    }
277
278    /**
279     * 保留 x 小数点后 y 位的值，但截断时要四舍五入。
280     */
281    public static <T> QueryColumn round(LambdaGetter<T> columnX, Integer y) {
282        return new FunctionQueryColumn(ROUND, LambdaUtil.getQueryColumn(columnX), number(y));
283    }
284
285    /**
286     * 返回 x 的 y 次方。
287     */
288    public static QueryColumn pow(String columnX, String columnY) {
289        return new FunctionQueryColumn(POW, columnX, columnY);
290    }
291
292    /**
293     * 返回 x 的 y 次方。
294     */
295    public static QueryColumn pow(QueryColumn columnX, QueryColumn columnY) {
296        return new FunctionQueryColumn(POW, columnX, columnY);
297    }
298
299    /**
300     * 返回 x 的 y 次方。
301     */
302    public static <X, Y> QueryColumn pow(LambdaGetter<X> columnX, LambdaGetter<Y> columnY) {
303        return new FunctionQueryColumn(POW, LambdaUtil.getQueryColumn(columnX), LambdaUtil.getQueryColumn(columnY));
304    }
305
306    /**
307     * 返回 x 的 y 次方。
308     */
309    public static QueryColumn pow(String columnX, Integer y) {
310        return new FunctionQueryColumn(POW, new QueryColumn(columnX), number(y));
311    }
312
313    /**
314     * 返回 x 的 y 次方。
315     */
316    public static QueryColumn pow(QueryColumn columnX, Integer y) {
317        return new FunctionQueryColumn(POW, columnX, number(y));
318    }
319
320    /**
321     * 返回 x 的 y 次方。
322     */
323    public static <T> QueryColumn pow(LambdaGetter<T> columnX, Integer y) {
324        return new FunctionQueryColumn(POW, LambdaUtil.getQueryColumn(columnX), number(y));
325    }
326
327    /**
328     * 返回 x 的 y 次方。
329     */
330    public static QueryColumn power(String columnX, String columnY) {
331        return new FunctionQueryColumn(POWER, columnX, columnY);
332    }
333
334    /**
335     * 返回 x 的 y 次方。
336     */
337    public static QueryColumn power(QueryColumn columnX, QueryColumn columnY) {
338        return new FunctionQueryColumn(POWER, columnX, columnY);
339    }
340
341    /**
342     * 返回 x 的 y 次方。
343     */
344    public static <X, Y> QueryColumn power(LambdaGetter<X> columnX, LambdaGetter<Y> columnY) {
345        return new FunctionQueryColumn(POWER, LambdaUtil.getQueryColumn(columnX), LambdaUtil.getQueryColumn(columnY));
346    }
347
348    /**
349     * 返回 x 的 y 次方。
350     */
351    public static QueryColumn power(String columnX, Integer y) {
352        return new FunctionQueryColumn(POWER, new QueryColumn(columnX), number(y));
353    }
354
355    /**
356     * 返回 x 的 y 次方。
357     */
358    public static QueryColumn power(QueryColumn columnX, Integer y) {
359        return new FunctionQueryColumn(POWER, columnX, number(y));
360    }
361
362    /**
363     * 返回 x 的 y 次方。
364     */
365    public static <T> QueryColumn power(LambdaGetter<T> columnX, Integer y) {
366        return new FunctionQueryColumn(POWER, LambdaUtil.getQueryColumn(columnX), number(y));
367    }
368
369    /**
370     * 返回 x 的平方根。
371     */
372    public static QueryColumn sqrt(String columnX) {
373        return new FunctionQueryColumn(SQRT, columnX);
374    }
375
376    /**
377     * 返回 x 的平方根。
378     */
379    public static QueryColumn sqrt(QueryColumn columnX) {
380        return new FunctionQueryColumn(SQRT, columnX);
381    }
382
383    /**
384     * 返回 x 的平方根。
385     */
386    public static <T> QueryColumn sqrt(LambdaGetter<T> columnX) {
387        return new FunctionQueryColumn(SQRT, LambdaUtil.getQueryColumn(columnX));
388    }
389
390    /**
391     * 返回 e 的 x 次方。
392     */
393    public static QueryColumn exp(String columnX) {
394        return new FunctionQueryColumn(EXP, columnX);
395    }
396
397    /**
398     * 返回 e 的 x 次方。
399     */
400    public static QueryColumn exp(QueryColumn columnX) {
401        return new FunctionQueryColumn(EXP, columnX);
402    }
403
404    /**
405     * 返回 e 的 x 次方。
406     */
407    public static <T> QueryColumn exp(LambdaGetter<T> columnX) {
408        return new FunctionQueryColumn(EXP, LambdaUtil.getQueryColumn(columnX));
409    }
410
411    /**
412     * 返回 x 除以 y 以后的余数。
413     */
414    public static QueryColumn mod(String columnX, String columnY) {
415        return new FunctionQueryColumn(MOD, columnX, columnY);
416    }
417
418    /**
419     * 返回 x 除以 y 以后的余数。
420     */
421    public static QueryColumn mod(QueryColumn columnX, QueryColumn columnY) {
422        return new FunctionQueryColumn(MOD, columnX, columnY);
423    }
424
425    /**
426     * 返回 x 除以 y 以后的余数。
427     */
428    public static <X, Y> QueryColumn mod(LambdaGetter<X> columnX, LambdaGetter<Y> columnY) {
429        return new FunctionQueryColumn(MOD, LambdaUtil.getQueryColumn(columnX), LambdaUtil.getQueryColumn(columnY));
430    }
431
432    /**
433     * 返回 x 除以 y 以后的余数。
434     */
435    public static QueryColumn mod(String columnX, Integer y) {
436        return new FunctionQueryColumn(MOD, new QueryColumn(columnX), number(y));
437    }
438
439    /**
440     * 返回 x 除以 y 以后的余数。
441     */
442    public static QueryColumn mod(QueryColumn columnX, Integer y) {
443        return new FunctionQueryColumn(MOD, columnX, number(y));
444    }
445
446    /**
447     * 返回 x 除以 y 以后的余数。
448     */
449    public static <T> QueryColumn mod(LambdaGetter<T> columnX, Integer y) {
450        return new FunctionQueryColumn(MOD, LambdaUtil.getQueryColumn(columnX), number(y));
451    }
452
453    /**
454     * 返回自然对数（以 e 为底的对数）。
455     */
456    public static QueryColumn log(String columnX) {
457        return new FunctionQueryColumn(LOG, columnX);
458    }
459
460    /**
461     * 返回自然对数（以 e 为底的对数）。
462     */
463    public static QueryColumn log(QueryColumn columnX) {
464        return new FunctionQueryColumn(LOG, columnX);
465    }
466
467    /**
468     * 返回自然对数（以 e 为底的对数）。
469     */
470    public static <T> QueryColumn log(LambdaGetter<T> columnX) {
471        return new FunctionQueryColumn(LOG, LambdaUtil.getQueryColumn(columnX));
472    }
473
474    /**
475     * 返回以 10 为底的对数。
476     */
477    public static QueryColumn log10(String columnX) {
478        return new FunctionQueryColumn(LOG10, columnX);
479    }
480
481    /**
482     * 返回以 10 为底的对数。
483     */
484    public static QueryColumn log10(QueryColumn columnX) {
485        return new FunctionQueryColumn(LOG10, columnX);
486    }
487
488    /**
489     * 返回以 10 为底的对数。
490     */
491    public static <T> QueryColumn log10(LambdaGetter<T> columnX) {
492        return new FunctionQueryColumn(LOG10, LambdaUtil.getQueryColumn(columnX));
493    }
494
495    /**
496     * 将角度转换为弧度。
497     */
498    public static QueryColumn radians(String columnX) {
499        return new FunctionQueryColumn(RADIANS, columnX);
500    }
501
502    /**
503     * 将角度转换为弧度。
504     */
505    public static QueryColumn radians(QueryColumn columnX) {
506        return new FunctionQueryColumn(RADIANS, columnX);
507    }
508
509    /**
510     * 将角度转换为弧度。
511     */
512    public static <T> QueryColumn radians(LambdaGetter<T> columnX) {
513        return new FunctionQueryColumn(RADIANS, LambdaUtil.getQueryColumn(columnX));
514    }
515
516    /**
517     * 将弧度转换为角度。
518     */
519    public static QueryColumn degrees(String columnX) {
520        return new FunctionQueryColumn(DEGREES, columnX);
521    }
522
523    /**
524     * 将弧度转换为角度。
525     */
526    public static QueryColumn degrees(QueryColumn columnX) {
527        return new FunctionQueryColumn(DEGREES, columnX);
528    }
529
530    /**
531     * 将弧度转换为角度。
532     */
533    public static <T> QueryColumn degrees(LambdaGetter<T> columnX) {
534        return new FunctionQueryColumn(DEGREES, LambdaUtil.getQueryColumn(columnX));
535    }
536
537    /**
538     * 求正弦值。
539     */
540    public static QueryColumn sin(String columnX) {
541        return new FunctionQueryColumn(SIN, columnX);
542    }
543
544    /**
545     * 求正弦值。
546     */
547    public static QueryColumn sin(QueryColumn columnX) {
548        return new FunctionQueryColumn(SIN, columnX);
549    }
550
551    /**
552     * 求正弦值。
553     */
554    public static <T> QueryColumn sin(LambdaGetter<T> columnX) {
555        return new FunctionQueryColumn(SIN, LambdaUtil.getQueryColumn(columnX));
556    }
557
558    /**
559     * 求反正弦值。
560     */
561    public static QueryColumn asin(String columnX) {
562        return new FunctionQueryColumn(ASIN, columnX);
563    }
564
565    /**
566     * 求反正弦值。
567     */
568    public static QueryColumn asin(QueryColumn columnX) {
569        return new FunctionQueryColumn(ASIN, columnX);
570    }
571
572    /**
573     * 求反正弦值。
574     */
575    public static <T> QueryColumn asin(LambdaGetter<T> columnX) {
576        return new FunctionQueryColumn(ASIN, LambdaUtil.getQueryColumn(columnX));
577    }
578
579    /**
580     * 求余弦值。
581     */
582    public static QueryColumn cos(String columnX) {
583        return new FunctionQueryColumn(COS, columnX);
584    }
585
586    /**
587     * 求余弦值。
588     */
589    public static QueryColumn cos(QueryColumn columnX) {
590        return new FunctionQueryColumn(COS, columnX);
591    }
592
593    /**
594     * 求余弦值。
595     */
596    public static <T> QueryColumn cos(LambdaGetter<T> columnX) {
597        return new FunctionQueryColumn(COS, LambdaUtil.getQueryColumn(columnX));
598    }
599
600    /**
601     * 求反余弦值。
602     */
603    public static QueryColumn acos(String columnX) {
604        return new FunctionQueryColumn(ACOS, columnX);
605    }
606
607    /**
608     * 求反余弦值。
609     */
610    public static QueryColumn acos(QueryColumn columnX) {
611        return new FunctionQueryColumn(ACOS, columnX);
612    }
613
614    /**
615     * 求反余弦值。
616     */
617    public static <T> QueryColumn acos(LambdaGetter<T> columnX) {
618        return new FunctionQueryColumn(ACOS, LambdaUtil.getQueryColumn(columnX));
619    }
620
621    /**
622     * 求正切值。
623     */
624    public static QueryColumn tan(String columnX) {
625        return new FunctionQueryColumn(TAN, columnX);
626    }
627
628    /**
629     * 求正切值。
630     */
631    public static QueryColumn tan(QueryColumn columnX) {
632        return new FunctionQueryColumn(TAN, columnX);
633    }
634
635    /**
636     * 求正切值。
637     */
638    public static <T> QueryColumn tan(LambdaGetter<T> columnX) {
639        return new FunctionQueryColumn(TAN, LambdaUtil.getQueryColumn(columnX));
640    }
641
642    /**
643     * 求反正切值。
644     */
645    public static QueryColumn atan(String columnX) {
646        return new FunctionQueryColumn(ATAN, columnX);
647    }
648
649    /**
650     * 求反正切值。
651     */
652    public static QueryColumn atan(QueryColumn columnX) {
653        return new FunctionQueryColumn(ATAN, columnX);
654    }
655
656    /**
657     * 求反正切值。
658     */
659    public static <T> QueryColumn atan(LambdaGetter<T> columnX) {
660        return new FunctionQueryColumn(ATAN, LambdaUtil.getQueryColumn(columnX));
661    }
662
663    /**
664     * 求余切值。
665     */
666    public static QueryColumn cot(String columnX) {
667        return new FunctionQueryColumn(COT, columnX);
668    }
669
670    /**
671     * 求余切值。
672     */
673    public static QueryColumn cot(QueryColumn columnX) {
674        return new FunctionQueryColumn(COT, columnX);
675    }
676
677    /**
678     * 求余切值。
679     */
680    public static <T> QueryColumn cot(LambdaGetter<T> columnX) {
681        return new FunctionQueryColumn(COT, LambdaUtil.getQueryColumn(columnX));
682    }
683
684    // === 字符串函数 ===
685
686    /**
687     * 返回字符串 s 的字符数。
688     */
689    public static QueryColumn charLength(String columnS) {
690        return new FunctionQueryColumn(CHAR_LENGTH, columnS);
691    }
692
693    /**
694     * 返回字符串 s 的字符数。
695     */
696    public static QueryColumn charLength(QueryColumn columnS) {
697        return new FunctionQueryColumn(CHAR_LENGTH, columnS);
698    }
699
700    /**
701     * 返回字符串 s 的字符数。
702     */
703    public static <T> QueryColumn charLength(LambdaGetter<T> columnS) {
704        return new FunctionQueryColumn(CHAR_LENGTH, LambdaUtil.getQueryColumn(columnS));
705    }
706
707    /**
708     * 返回字符串 s 的长度。
709     */
710    public static QueryColumn length(String columnS) {
711        return new FunctionQueryColumn(LENGTH, columnS);
712    }
713
714    /**
715     * 返回字符串 s 的长度。
716     */
717    public static QueryColumn length(QueryColumn columnS) {
718        return new FunctionQueryColumn(LENGTH, columnS);
719    }
720
721    /**
722     * 返回字符串 s 的长度。
723     */
724    public static <T> QueryColumn length(LambdaGetter<T> columnS) {
725        return new FunctionQueryColumn(LENGTH, LambdaUtil.getQueryColumn(columnS));
726    }
727
728    /**
729     * 将字符串 s1，s2 等多个字符串合并为一个字符串。
730     */
731    public static QueryColumn concat(String columnS1, String columnS2, String... columnN) {
732        return new FunctionQueryColumn(CONCAT, ArrayUtil.concat(new String[]{columnS1, columnS2}, columnN));
733    }
734
735    /**
736     * 将字符串 s1，s2 等多个字符串合并为一个字符串。
737     */
738    public static QueryColumn concat(QueryColumn columnS1, QueryColumn columnS2, QueryColumn... columnN) {
739        return new FunctionQueryColumn(CONCAT, ArrayUtil.concat(new QueryColumn[]{columnS1, columnS2}, columnN));
740    }
741
742    /**
743     * 同 CONCAT(s1, s2, ...)，但是每个字符串之间要加上 x。
744     */
745    public static QueryColumn concatWs(String columnX, String columnS1, String columnS2, String... columnN) {
746        return new FunctionQueryColumn(CONCAT_WS, ArrayUtil.concat(new String[]{columnX, columnS1, columnS2}, columnN));
747    }
748
749    /**
750     * 同 CONCAT(s1, s2, ...)，但是每个字符串之间要加上 x。
751     */
752    public static QueryColumn concatWs(QueryColumn columnX, QueryColumn columnS1, QueryColumn columnS2, QueryColumn... columnN) {
753        return new FunctionQueryColumn(CONCAT_WS, ArrayUtil.concat(new QueryColumn[]{columnX, columnS1, columnS2}, columnN));
754    }
755
756    /**
757     * 将字符串 s2 替换 s1 的 x 位置开始长度为 len 的字符串。
758     */
759    public static QueryColumn insert(String columnS1, String columnX, String columnLen, String columnS2) {
760        return new FunctionQueryColumn(INSERT, columnS1, columnX, columnLen, columnS2);
761    }
762
763    /**
764     * 将字符串 s2 替换 s1 的 x 位置开始长度为 len 的字符串。
765     */
766    public static QueryColumn insert(QueryColumn columnS1, QueryColumn columnX, QueryColumn columnLen, QueryColumn columnS2) {
767        return new FunctionQueryColumn(INSERT, columnS1, columnX, columnLen, columnS2);
768    }
769
770    /**
771     * 将字符串 s 的所有字符都变成大写字母。
772     */
773    public static QueryColumn upper(String columnS) {
774        return new FunctionQueryColumn(UPPER, columnS);
775    }
776
777    /**
778     * 将字符串 s 的所有字符都变成大写字母。
779     */
780    public static QueryColumn upper(QueryColumn columnS) {
781        return new FunctionQueryColumn(UPPER, columnS);
782    }
783
784    /**
785     * 将字符串 s 的所有字符都变成大写字母。
786     */
787    public static <T> QueryColumn upper(LambdaGetter<T> columnS) {
788        return new FunctionQueryColumn(UPPER, LambdaUtil.getQueryColumn(columnS));
789    }
790
791    /**
792     * 将字符串 s 的所有字符都变成小写字母。
793     */
794    public static QueryColumn lower(String columnS) {
795        return new FunctionQueryColumn(LOWER, columnS);
796    }
797
798    /**
799     * 将字符串 s 的所有字符都变成小写字母。
800     */
801    public static QueryColumn lower(QueryColumn columnS) {
802        return new FunctionQueryColumn(LOWER, columnS);
803    }
804
805    /**
806     * 将字符串 s 的所有字符都变成小写字母。
807     */
808    public static <T> QueryColumn lower(LambdaGetter<T> columnS) {
809        return new FunctionQueryColumn(LOWER, LambdaUtil.getQueryColumn(columnS));
810    }
811
812    /**
813     * 返回字符串 s 的前 n 个字符。
814     */
815    public static QueryColumn left(String columnS, int length) {
816        return new FunctionQueryColumn(LEFT, string(columnS), number(length));
817    }
818
819    /**
820     * 返回字符串 s 的前 n 个字符。
821     */
822    public static QueryColumn left(QueryColumn columnS, int length) {
823        return new FunctionQueryColumn(LEFT, columnS, number(length));
824    }
825
826    /**
827     * 返回字符串 s 的前 n 个字符。
828     */
829    public static <S, N> QueryColumn left(LambdaGetter<S> columnS, int length) {
830        return new FunctionQueryColumn(LEFT, LambdaUtil.getQueryColumn(columnS), number(length));
831    }
832
833
834    /**
835     * 返回字符串 s 的后 length 个字符。
836     */
837    public static QueryColumn right(String columnS, int length) {
838        return new FunctionQueryColumn(RIGHT, string(columnS), number(length));
839    }
840
841    /**
842     * 返回字符串 s 的后 length 个字符。
843     */
844    public static QueryColumn right(QueryColumn columnS, int length) {
845        return new FunctionQueryColumn(RIGHT, columnS, number(length));
846    }
847
848    /**
849     * 返回字符串 s 的后 length 个字符。
850     */
851    public static <S, N> QueryColumn right(LambdaGetter<S> columnS, int length) {
852        return new FunctionQueryColumn(RIGHT, LambdaUtil.getQueryColumn(columnS), number(length));
853    }
854
855    /**
856     * 字符串 s2 来填充 s1 的开始处，使字符串长度达到 len。
857     */
858    public static QueryColumn lpad(String columnS1, String columnLen, String columnS2) {
859        return new FunctionQueryColumn(LPAD, columnS1, columnLen, columnS2);
860    }
861
862    /**
863     * 字符串 s2 来填充 s1 的开始处，使字符串长度达到 len。
864     */
865    public static QueryColumn lpad(QueryColumn columnS1, QueryColumn columnLen, QueryColumn columnS2) {
866        return new FunctionQueryColumn(LPAD, columnS1, columnLen, columnS2);
867    }
868
869    /**
870     * 字符串 s2 来填充 s1 的开始处，使字符串长度达到 len。
871     */
872    public static <S1, L, S2> QueryColumn lpad(LambdaGetter<S1> columnS1, LambdaGetter<L> columnLen, LambdaGetter<S2> columnS2) {
873        return new FunctionQueryColumn(LPAD, LambdaUtil.getQueryColumn(columnS1), LambdaUtil.getQueryColumn(columnLen), LambdaUtil.getQueryColumn(columnS2));
874    }
875
876    /**
877     * 字符串 s2 来填充 s1 的结尾处，使字符串长度达到 len。
878     */
879    public static QueryColumn rpad(String columnS1, String columnLen, String columnS2) {
880        return new FunctionQueryColumn(RPAD, columnS1, columnLen, columnS2);
881    }
882
883    /**
884     * 字符串 s2 来填充 s1 的结尾处，使字符串长度达到 len。
885     */
886    public static QueryColumn rpad(QueryColumn columnS1, QueryColumn columnLen, QueryColumn columnS2) {
887        return new FunctionQueryColumn(RPAD, columnS1, columnLen, columnS2);
888    }
889
890    /**
891     * 字符串 s2 来填充 s1 的结尾处，使字符串长度达到 len。
892     */
893    public static <S1, L, S2> QueryColumn rpad(LambdaGetter<S1> columnS1, LambdaGetter<L> columnLen, LambdaGetter<S2> columnS2) {
894        return new FunctionQueryColumn(RPAD, LambdaUtil.getQueryColumn(columnS1), LambdaUtil.getQueryColumn(columnLen), LambdaUtil.getQueryColumn(columnS2));
895    }
896
897    /**
898     * 去掉字符串 s 开始处的空格。
899     */
900    public static QueryColumn ltrim(String columnS) {
901        return new FunctionQueryColumn(LTRIM, columnS);
902    }
903
904    /**
905     * 去掉字符串 s 开始处的空格。
906     */
907    public static QueryColumn ltrim(QueryColumn columnS) {
908        return new FunctionQueryColumn(LTRIM, columnS);
909    }
910
911    /**
912     * 去掉字符串 s 开始处的空格。
913     */
914    public static <T> QueryColumn ltrim(LambdaGetter<T> columnS) {
915        return new FunctionQueryColumn(LTRIM, LambdaUtil.getQueryColumn(columnS));
916    }
917
918    /**
919     * 去掉字符串 s 结尾处的空格。
920     */
921    public static QueryColumn rtrim(String columnS) {
922        return new FunctionQueryColumn(RTRIM, columnS);
923    }
924
925    /**
926     * 去掉字符串 s 结尾处的空格。
927     */
928    public static QueryColumn rtrim(QueryColumn columnS) {
929        return new FunctionQueryColumn(RTRIM, columnS);
930    }
931
932    /**
933     * 去掉字符串 s 结尾处的空格。
934     */
935    public static <T> QueryColumn rtrim(LambdaGetter<T> columnS) {
936        return new FunctionQueryColumn(RTRIM, LambdaUtil.getQueryColumn(columnS));
937    }
938
939    /**
940     * 去掉字符串 s 开始处和结尾处的空格。
941     */
942    public static QueryColumn trim(QueryColumn columnS) {
943        return new FunctionQueryColumn(TRIM, columnS);
944    }
945
946    /**
947     * 将字符串 s 重复 n 次。
948     */
949    public static QueryColumn repeat(String columnS, String columnN) {
950        return new FunctionQueryColumn(REPEAT, columnS, columnN);
951    }
952
953    /**
954     * 将字符串 s 重复 n 次。
955     */
956    public static QueryColumn repeat(QueryColumn columnS, QueryColumn columnN) {
957        return new FunctionQueryColumn(REPEAT, columnS, columnN);
958    }
959
960    /**
961     * 将字符串 s 重复 n 次。
962     */
963    public static <S, N> QueryColumn repeat(LambdaGetter<S> columnS, LambdaGetter<N> columnN) {
964        return new FunctionQueryColumn(REPEAT, LambdaUtil.getQueryColumn(columnS), LambdaUtil.getQueryColumn(columnN));
965    }
966
967    /**
968     * 将字符串 s 重复 n 次。
969     */
970    public static QueryColumn repeat(String columnX, Integer n) {
971        return new FunctionQueryColumn(REPEAT, new QueryColumn(columnX), number(n));
972    }
973
974    /**
975     * 将字符串 s 重复 n 次。
976     */
977    public static QueryColumn repeat(QueryColumn columnX, Integer n) {
978        return new FunctionQueryColumn(REPEAT, columnX, number(n));
979    }
980
981    /**
982     * 将字符串 s 重复 n 次。
983     */
984    public static <T> QueryColumn repeat(LambdaGetter<T> columnX, Integer n) {
985        return new FunctionQueryColumn(REPEAT, LambdaUtil.getQueryColumn(columnX), number(n));
986    }
987
988    /**
989     * 返回 n 个空格。
990     */
991    public static QueryColumn space(String columnN) {
992        return new FunctionQueryColumn(SPACE, columnN);
993    }
994
995    /**
996     * 返回 n 个空格。
997     */
998    public static QueryColumn space(QueryColumn columnN) {
999        return new FunctionQueryColumn(SPACE, columnN);
1000    }
1001
1002    /**
1003     * 返回 n 个空格。
1004     */
1005    public static <T> QueryColumn space(LambdaGetter<T> columnN) {
1006        return new FunctionQueryColumn(SPACE, LambdaUtil.getQueryColumn(columnN));
1007    }
1008
1009    /**
1010     * 用字符串 s2 代替字符串 s 中的字符串 s1。
1011     */
1012    public static QueryColumn replace(String columnS, String columnS1, String columnS2) {
1013        return new StringFunctionQueryColumn(REPLACE, columnS, columnS1, columnS2);
1014    }
1015
1016    /**
1017     * 用字符串 s2 代替字符串 s 中的字符串 s1。
1018     */
1019    public static QueryColumn replace(QueryColumn columnS, QueryColumn columnS1, QueryColumn columnS2) {
1020        return new FunctionQueryColumn(REPLACE, columnS, columnS1, columnS2);
1021    }
1022
1023    /**
1024     * 用字符串 s2 代替字符串 s 中的字符串 s1。
1025     */
1026    public static <S, S1, S2> QueryColumn replace(LambdaGetter<S> columnS, LambdaGetter<S1> columnS1, LambdaGetter<S2> columnS2) {
1027        return new FunctionQueryColumn(REPLACE, LambdaUtil.getQueryColumn(columnS), LambdaUtil.getQueryColumn(columnS1), LambdaUtil.getQueryColumn(columnS2));
1028    }
1029
1030    /**
1031     * 比较字符串 s1 和 s2。
1032     */
1033    public static QueryColumn strcmp(String columnS1, String columnS2) {
1034        return new FunctionQueryColumn(STRCMP, columnS1, columnS2);
1035    }
1036
1037    /**
1038     * 比较字符串 s1 和 s2。
1039     */
1040    public static QueryColumn strcmp(QueryColumn columnS1, QueryColumn columnS2) {
1041        return new FunctionQueryColumn(STRCMP, columnS1, columnS2);
1042    }
1043
1044    /**
1045     * 比较字符串 s1 和 s2。
1046     */
1047    public static <S1, S2> QueryColumn strcmp(LambdaGetter<S1> columnS1, LambdaGetter<S2> columnS2) {
1048        return new FunctionQueryColumn(STRCMP, LambdaUtil.getQueryColumn(columnS1), LambdaUtil.getQueryColumn(columnS2));
1049    }
1050
1051
1052    /**
1053     * 获取从字符串 s 中的第 position 个位置开始长度为 length 的字符串。
1054     */
1055    public static QueryColumn substring(String columnS, int position) {
1056        return new FunctionQueryColumn(SUBSTRING, string(columnS), number(position));
1057    }
1058
1059    /**
1060     * 获取从字符串 s 中的第 position 个位置开始长度为 length 的字符串。
1061     */
1062    public static QueryColumn substring(QueryColumn columnS, int position) {
1063        return new FunctionQueryColumn(SUBSTRING, columnS, number(position));
1064    }
1065
1066    /**
1067     * 获取从字符串 s 中的第 position 个位置开始长度为 length 的字符串。
1068     */
1069    public static <S, N, L> QueryColumn substring(LambdaGetter<S> columnS, int position) {
1070        return new FunctionQueryColumn(SUBSTRING, LambdaUtil.getQueryColumn(columnS), number(position));
1071    }
1072
1073    /**
1074     * 获取从字符串 s 中的第 position 个位置开始长度为 length 的字符串。
1075     */
1076    public static QueryColumn substring(String columnS, int position, int length) {
1077        return new FunctionQueryColumn(SUBSTRING, string(columnS), number(position), number(length));
1078    }
1079
1080    /**
1081     * 获取从字符串 s 中的第 position 个位置开始长度为 length 的字符串。
1082     */
1083    public static QueryColumn substring(QueryColumn columnS, int position, int length) {
1084        return new FunctionQueryColumn(SUBSTRING, columnS, number(position), number(length));
1085    }
1086
1087    /**
1088     * 获取从字符串 s 中的第 position 个位置开始长度为 length 的字符串。
1089     */
1090    public static <S, N, L> QueryColumn substring(LambdaGetter<S> columnS, int position, int length) {
1091        return new FunctionQueryColumn(SUBSTRING, LambdaUtil.getQueryColumn(columnS), number(position), number(length));
1092    }
1093
1094    /**
1095     * 从字符串 s 中获取 s1 的开始位置。
1096     */
1097    public static QueryColumn instr(String columnS, String columnS1) {
1098        return new FunctionQueryColumn(INSTR, columnS, columnS1);
1099    }
1100
1101    /**
1102     * 从字符串 s 中获取 s1 的开始位置。
1103     */
1104    public static QueryColumn instr(QueryColumn columnS, QueryColumn columnS1) {
1105        return new FunctionQueryColumn(INSTR, columnS, columnS1);
1106    }
1107
1108    /**
1109     * 从字符串 s 中获取 s1 的开始位置。
1110     */
1111    public static <S, S1> QueryColumn instr(LambdaGetter<S> columnS, LambdaGetter<S1> columnS1) {
1112        return new FunctionQueryColumn(INSTR, LambdaUtil.getQueryColumn(columnS), LambdaUtil.getQueryColumn(columnS1));
1113    }
1114
1115    /**
1116     * 将字符串 s 的顺序反过来。
1117     */
1118    public static QueryColumn reverse(String columnS) {
1119        return new FunctionQueryColumn(REVERSE, columnS);
1120    }
1121
1122    /**
1123     * 将字符串 s 的顺序反过来。
1124     */
1125    public static QueryColumn reverse(QueryColumn columnS) {
1126        return new FunctionQueryColumn(REVERSE, columnS);
1127    }
1128
1129    /**
1130     * 将字符串 s 的顺序反过来。
1131     */
1132    public static <T> QueryColumn reverse(LambdaGetter<T> columnS) {
1133        return new FunctionQueryColumn(REVERSE, LambdaUtil.getQueryColumn(columnS));
1134    }
1135
1136    /**
1137     * 返回第 n 个字符串。
1138     */
1139    public static QueryColumn elt(String columnN, String columnS1, String... columnSn) {
1140        return new FunctionQueryColumn(ELT, ArrayUtil.concat(new String[]{columnN, columnS1}, columnSn));
1141    }
1142
1143    /**
1144     * 返回第 n 个字符串。
1145     */
1146    public static QueryColumn elt(QueryColumn columnN, QueryColumn columnS1, QueryColumn... columnSn) {
1147        return new FunctionQueryColumn(ELT, ArrayUtil.concat(new QueryColumn[]{columnN, columnS1}, columnSn));
1148    }
1149
1150    /**
1151     * 返回第一个与字符串 s 匹配的字符串的位置。
1152     */
1153    public static QueryColumn field(String columnS, String columnS1, String... columnSn) {
1154        return new FunctionQueryColumn(FIELD, ArrayUtil.concat(new String[]{columnS, columnS1}, columnSn));
1155    }
1156
1157    /**
1158     * 返回第一个与字符串 s 匹配的字符串的位置。
1159     */
1160    public static QueryColumn field(QueryColumn columnS, QueryColumn columnS1, QueryColumn... columnSn) {
1161        return new FunctionQueryColumn(FIELD, ArrayUtil.concat(new QueryColumn[]{columnS, columnS1}, columnSn));
1162    }
1163
1164    /**
1165     * 返回在字符串 s2 中与 s1 匹配的字符串的位置。
1166     */
1167    public static QueryColumn findInSet(String columnS1, String columnS2) {
1168        return new FunctionQueryColumn(FIND_IN_SET, columnS1, columnS2);
1169    }
1170
1171    /**
1172     * 返回在字符串 s2 中与 s1 匹配的字符串的位置。
1173     */
1174    public static QueryColumn findInSet(QueryColumn columnS1, QueryColumn columnS2) {
1175        return new FunctionQueryColumn(FIND_IN_SET, columnS1, columnS2);
1176    }
1177
1178    /**
1179     * 返回在字符串 s2 中与 s1 匹配的字符串的位置。
1180     */
1181    public static <S1, S2> QueryColumn findInSet(LambdaGetter<S1> columnS1, LambdaGetter<S2> columnS2) {
1182        return new FunctionQueryColumn(FIND_IN_SET, LambdaUtil.getQueryColumn(columnS1), LambdaUtil.getQueryColumn(columnS2));
1183    }
1184
1185    // === 日期时间函数 ===
1186
1187    /**
1188     * 返回当前日期。
1189     */
1190    public static QueryColumn curDate() {
1191        return new FunctionQueryColumn(CURDATE);
1192    }
1193
1194    /**
1195     * 返回当前日期。
1196     */
1197    public static QueryColumn currentDate() {
1198        return new FunctionQueryColumn(CURRENT_DATE);
1199    }
1200
1201    /**
1202     * 返回当前时间。
1203     */
1204    public static QueryColumn curTime() {
1205        return new FunctionQueryColumn(CURTIME);
1206    }
1207
1208    /**
1209     * 返回当前时间。
1210     */
1211    public static QueryColumn currentTime() {
1212        return new FunctionQueryColumn(CURRENT_TIME);
1213    }
1214
1215    /**
1216     * 返回当前日期和时间。
1217     */
1218    public static QueryColumn now() {
1219        return new FunctionQueryColumn(NOW);
1220    }
1221
1222    /**
1223     * 返回当前日期和时间。
1224     */
1225    public static QueryColumn currentTimestamp() {
1226        return new FunctionQueryColumn(CURRENT_TIMESTAMP);
1227    }
1228
1229    /**
1230     * 返回当前日期和时间。
1231     */
1232    public static QueryColumn localTime() {
1233        return new FunctionQueryColumn(LOCALTIME);
1234    }
1235
1236    /**
1237     * 返回当前日期和时间。
1238     */
1239    public static QueryColumn sysDate() {
1240        return new FunctionQueryColumn(SYSDATE);
1241    }
1242
1243
1244    /**
1245     * 返回当前日期和时间。
1246     */
1247    public static QueryColumn localTimestamp() {
1248        return new FunctionQueryColumn(LOCALTIMESTAMP);
1249    }
1250
1251    /**
1252     * 以 UNIX 时间戳的形式返回当前时间。
1253     */
1254    public static QueryColumn unixTimestamp() {
1255        return new FunctionQueryColumn(UNIX_TIMESTAMP);
1256    }
1257
1258    /**
1259     * 将时间 d 以 UNIX 时间戳的形式返回。
1260     */
1261    public static QueryColumn unixTimestamp(String columnD) {
1262        return new FunctionQueryColumn(UNIX_TIMESTAMP, columnD);
1263    }
1264
1265    /**
1266     * 将时间 d 以 UNIX 时间戳的形式返回。
1267     */
1268    public static QueryColumn unixTimestamp(QueryColumn columnD) {
1269        return new FunctionQueryColumn(UNIX_TIMESTAMP, columnD);
1270    }
1271
1272    /**
1273     * 将时间 d 以 UNIX 时间戳的形式返回。
1274     */
1275    public static <T> QueryColumn unixTimestamp(LambdaGetter<T> columnD) {
1276        return new FunctionQueryColumn(UNIX_TIMESTAMP, LambdaUtil.getQueryColumn(columnD));
1277    }
1278
1279    /**
1280     * 把 UNIX 时间戳的时间转换为普通格式的时间。
1281     */
1282    public static QueryColumn fromUnixTime(String columnD) {
1283        return new FunctionQueryColumn(FROM_UNIXTIME, columnD);
1284    }
1285
1286    /**
1287     * 把 UNIX 时间戳的时间转换为普通格式的时间。
1288     */
1289    public static QueryColumn fromUnixTime(QueryColumn columnD) {
1290        return new FunctionQueryColumn(FROM_UNIXTIME, columnD);
1291    }
1292
1293    /**
1294     * 把 UNIX 时间戳的时间转换为普通格式的时间。
1295     */
1296    public static <T> QueryColumn fromUnixTime(LambdaGetter<T> columnD) {
1297        return new FunctionQueryColumn(FROM_UNIXTIME, LambdaUtil.getQueryColumn(columnD));
1298    }
1299
1300    /**
1301     * 返回 UTC（国际协调时间）日期。
1302     */
1303    public static QueryColumn utcDate() {
1304        return new FunctionQueryColumn(UTC_DATE);
1305    }
1306
1307    /**
1308     * 返回 UTC 时间。
1309     */
1310    public static QueryColumn utcTime() {
1311        return new FunctionQueryColumn(UTC_TIME);
1312    }
1313
1314    /**
1315     * 返回日期 d 中的月份值，范围是 1~12。
1316     */
1317    public static QueryColumn month(String columnD) {
1318        return new FunctionQueryColumn(MONTH, columnD);
1319    }
1320
1321    /**
1322     * 返回日期 d 中的月份值，范围是 1~12。
1323     */
1324    public static QueryColumn month(QueryColumn columnD) {
1325        return new FunctionQueryColumn(MONTH, columnD);
1326    }
1327
1328    /**
1329     * 返回日期 d 中的月份值，范围是 1~12。
1330     */
1331    public static <T> QueryColumn month(LambdaGetter<T> columnD) {
1332        return new FunctionQueryColumn(MONTH, LambdaUtil.getQueryColumn(columnD));
1333    }
1334
1335    /**
1336     * 返回日期 d 中的月份名称，如 january。
1337     */
1338    public static QueryColumn monthName(String columnD) {
1339        return new FunctionQueryColumn(MONTHNAME, columnD);
1340    }
1341
1342    /**
1343     * 返回日期 d 中的月份名称，如 january。
1344     */
1345    public static QueryColumn monthName(QueryColumn columnD) {
1346        return new FunctionQueryColumn(MONTHNAME, columnD);
1347    }
1348
1349    /**
1350     * 返回日期 d 中的月份名称，如 january。
1351     */
1352    public static <T> QueryColumn monthName(LambdaGetter<T> columnD) {
1353        return new FunctionQueryColumn(MONTHNAME, LambdaUtil.getQueryColumn(columnD));
1354    }
1355
1356    /**
1357     * 返回日期 d 是星期几，如 Monday。
1358     */
1359    public static QueryColumn dayName(String columnD) {
1360        return new FunctionQueryColumn(DAYNAME, columnD);
1361    }
1362
1363    /**
1364     * 返回日期 d 是星期几，如 Monday。
1365     */
1366    public static QueryColumn dayName(QueryColumn columnD) {
1367        return new FunctionQueryColumn(DAYNAME, columnD);
1368    }
1369
1370    /**
1371     * 返回日期 d 是星期几，如 Monday。
1372     */
1373    public static <T> QueryColumn dayName(LambdaGetter<T> columnD) {
1374        return new FunctionQueryColumn(DAYNAME, LambdaUtil.getQueryColumn(columnD));
1375    }
1376
1377    /**
1378     * 返回日期 d 是星期几，1 表示星期日，2 表示星期二。
1379     */
1380    public static QueryColumn dayOfWeek(String columnD) {
1381        return new FunctionQueryColumn(DAYOFWEEK, columnD);
1382    }
1383
1384    /**
1385     * 返回日期 d 是星期几，1 表示星期日，2 表示星期二。
1386     */
1387    public static QueryColumn dayOfWeek(QueryColumn columnD) {
1388        return new FunctionQueryColumn(DAYOFWEEK, columnD);
1389    }
1390
1391    /**
1392     * 返回日期 d 是星期几，1 表示星期日，2 表示星期二。
1393     */
1394    public static <T> QueryColumn dayOfWeek(LambdaGetter<T> columnD) {
1395        return new FunctionQueryColumn(DAYOFWEEK, LambdaUtil.getQueryColumn(columnD));
1396    }
1397
1398    /**
1399     * 返回日期 d 是星期几，0 表示星期一，1 表示星期二。
1400     */
1401    public static QueryColumn weekday(String columnD) {
1402        return new FunctionQueryColumn(WEEKDAY, columnD);
1403    }
1404
1405    /**
1406     * 返回日期 d 是星期几，0 表示星期一，1 表示星期二。
1407     */
1408    public static QueryColumn weekday(QueryColumn columnD) {
1409        return new FunctionQueryColumn(WEEKDAY, columnD);
1410    }
1411
1412    /**
1413     * 返回日期 d 是星期几，0 表示星期一，1 表示星期二。
1414     */
1415    public static <T> QueryColumn weekday(LambdaGetter<T> columnD) {
1416        return new FunctionQueryColumn(WEEKDAY, LambdaUtil.getQueryColumn(columnD));
1417    }
1418
1419    /**
1420     * 计算日期 d 是本年的第几个星期，范围是 0-53。
1421     */
1422    public static QueryColumn week(String columnD) {
1423        return new FunctionQueryColumn(WEEK, columnD);
1424    }
1425
1426    /**
1427     * 计算日期 d 是本年的第几个星期，范围是 0-53。
1428     */
1429    public static QueryColumn week(QueryColumn columnD) {
1430        return new FunctionQueryColumn(WEEK, columnD);
1431    }
1432
1433    /**
1434     * 计算日期 d 是本年的第几个星期，范围是 0-53。
1435     */
1436    public static <T> QueryColumn week(LambdaGetter<T> columnD) {
1437        return new FunctionQueryColumn(WEEK, LambdaUtil.getQueryColumn(columnD));
1438    }
1439
1440    /**
1441     * 计算日期 d 是本年的第几个星期，范围是 1-53。
1442     */
1443    public static QueryColumn weekOfYear(String columnD) {
1444        return new FunctionQueryColumn(WEEKOFYEAR, columnD);
1445    }
1446
1447    /**
1448     * 计算日期 d 是本年的第几个星期，范围是 1-53。
1449     */
1450    public static QueryColumn weekOfYear(QueryColumn columnD) {
1451        return new FunctionQueryColumn(WEEKOFYEAR, columnD);
1452    }
1453
1454    /**
1455     * 计算日期 d 是本年的第几个星期，范围是 1-53。
1456     */
1457    public static <T> QueryColumn weekOfYear(LambdaGetter<T> columnD) {
1458        return new FunctionQueryColumn(WEEKOFYEAR, LambdaUtil.getQueryColumn(columnD));
1459    }
1460
1461    /**
1462     * 计算日期 d 是本年的第几天。
1463     */
1464    public static QueryColumn dayOfYear(String columnD) {
1465        return new FunctionQueryColumn(DAYOFYEAR, columnD);
1466    }
1467
1468    /**
1469     * 计算日期 d 是本年的第几天。
1470     */
1471    public static QueryColumn dayOfYear(QueryColumn columnD) {
1472        return new FunctionQueryColumn(DAYOFYEAR, columnD);
1473    }
1474
1475    /**
1476     * 计算日期 d 是本年的第几天。
1477     */
1478    public static <T> QueryColumn dayOfYear(LambdaGetter<T> columnD) {
1479        return new FunctionQueryColumn(DAYOFYEAR, LambdaUtil.getQueryColumn(columnD));
1480    }
1481
1482    /**
1483     * 计算日期 d 是本月的第几天。
1484     */
1485    public static QueryColumn dayOfMonth(String columnD) {
1486        return new FunctionQueryColumn(DAYOFMONTH, columnD);
1487    }
1488
1489    /**
1490     * 计算日期 d 是本月的第几天。
1491     */
1492    public static QueryColumn dayOfMonth(QueryColumn columnD) {
1493        return new FunctionQueryColumn(DAYOFMONTH, columnD);
1494    }
1495
1496    /**
1497     * 计算日期 d 是本月的第几天。
1498     */
1499    public static <T> QueryColumn dayOfMonth(LambdaGetter<T> columnD) {
1500        return new FunctionQueryColumn(DAYOFMONTH, LambdaUtil.getQueryColumn(columnD));
1501    }
1502
1503    /**
1504     * 返回日期 d 中的年份值。
1505     */
1506    public static QueryColumn year(String columnD) {
1507        return new FunctionQueryColumn(YEAR, columnD);
1508    }
1509
1510    /**
1511     * 返回日期 d 中的年份值。
1512     */
1513    public static QueryColumn year(QueryColumn columnD) {
1514        return new FunctionQueryColumn(YEAR, columnD);
1515    }
1516
1517    /**
1518     * 返回日期 d 中的年份值。
1519     */
1520    public static <T> QueryColumn year(LambdaGetter<T> columnD) {
1521        return new FunctionQueryColumn(YEAR, LambdaUtil.getQueryColumn(columnD));
1522    }
1523
1524    /**
1525     * 返回日期 d 中的天数值。
1526     */
1527    public static FunctionQueryColumn day(String columnD) {
1528        return new FunctionQueryColumn(DAY, columnD);
1529    }
1530
1531    /**
1532     * 返回日期 d 中的天数值。
1533     */
1534    public static FunctionQueryColumn day(QueryColumn columnD) {
1535        return new FunctionQueryColumn(DAY, columnD);
1536    }
1537
1538    /**
1539     * 返回日期 d 中的天数值。
1540     */
1541    public static <T> FunctionQueryColumn day(LambdaGetter<T> columnD) {
1542        return new FunctionQueryColumn(DAY, LambdaUtil.getQueryColumn(columnD));
1543    }
1544
1545    /**
1546     * 返回日期 d 是第几季度，范围 1-4。
1547     */
1548    public static QueryColumn quarter(String columnD) {
1549        return new FunctionQueryColumn(QUARTER, columnD);
1550    }
1551
1552    /**
1553     * 返回日期 d 是第几季度，范围 1-4。
1554     */
1555    public static QueryColumn quarter(QueryColumn columnD) {
1556        return new FunctionQueryColumn(QUARTER, columnD);
1557    }
1558
1559    /**
1560     * 返回日期 d 是第几季度，范围 1-4。
1561     */
1562    public static <T> QueryColumn quarter(LambdaGetter<T> columnD) {
1563        return new FunctionQueryColumn(QUARTER, LambdaUtil.getQueryColumn(columnD));
1564    }
1565
1566    /**
1567     * 返回时间 t 中的小时值。
1568     */
1569    public static QueryColumn hour(String columnT) {
1570        return new FunctionQueryColumn(HOUR, columnT);
1571    }
1572
1573    /**
1574     * 返回时间 t 中的小时值。
1575     */
1576    public static QueryColumn hour(QueryColumn columnT) {
1577        return new FunctionQueryColumn(HOUR, columnT);
1578    }
1579
1580    /**
1581     * 返回时间 t 中的小时值。
1582     */
1583    public static <T> QueryColumn hour(LambdaGetter<T> columnT) {
1584        return new FunctionQueryColumn(HOUR, LambdaUtil.getQueryColumn(columnT));
1585    }
1586
1587    /**
1588     * 返回时间 t 中的分钟值。
1589     */
1590    public static QueryColumn minute(String columnT) {
1591        return new FunctionQueryColumn(MINUTE, columnT);
1592    }
1593
1594    /**
1595     * 返回时间 t 中的分钟值。
1596     */
1597    public static QueryColumn minute(QueryColumn columnT) {
1598        return new FunctionQueryColumn(MINUTE, columnT);
1599    }
1600
1601    /**
1602     * 返回时间 t 中的分钟值。
1603     */
1604    public static <T> QueryColumn minute(LambdaGetter<T> columnT) {
1605        return new FunctionQueryColumn(MINUTE, LambdaUtil.getQueryColumn(columnT));
1606    }
1607
1608    /**
1609     * 返回时间 t 中的秒钟值。
1610     */
1611    public static QueryColumn second(String columnT) {
1612        return new FunctionQueryColumn(SECOND, columnT);
1613    }
1614
1615    /**
1616     * 返回时间 t 中的秒钟值。
1617     */
1618    public static QueryColumn second(QueryColumn columnT) {
1619        return new FunctionQueryColumn(SECOND, columnT);
1620    }
1621
1622    /**
1623     * 返回时间 t 中的秒钟值。
1624     */
1625    public static <T> QueryColumn second(LambdaGetter<T> columnT) {
1626        return new FunctionQueryColumn(SECOND, LambdaUtil.getQueryColumn(columnT));
1627    }
1628
1629    /**
1630     * 将时间 t 转换为秒。
1631     */
1632    public static QueryColumn timeToSec(String columnT) {
1633        return new FunctionQueryColumn(TIME_TO_SEC, columnT);
1634    }
1635
1636    /**
1637     * 将时间 t 转换为秒。
1638     */
1639    public static QueryColumn timeToSec(QueryColumn columnT) {
1640        return new FunctionQueryColumn(TIME_TO_SEC, columnT);
1641    }
1642
1643    /**
1644     * 将时间 t 转换为秒。
1645     */
1646    public static <T> QueryColumn timeToSec(LambdaGetter<T> columnT) {
1647        return new FunctionQueryColumn(TIME_TO_SEC, LambdaUtil.getQueryColumn(columnT));
1648    }
1649
1650    /**
1651     * 将以秒为单位的时间 s 转换为时分秒的格式。
1652     */
1653    public static QueryColumn secToTime(String columnS) {
1654        return new FunctionQueryColumn(SEC_TO_TIME, columnS);
1655    }
1656
1657    /**
1658     * 将以秒为单位的时间 s 转换为时分秒的格式。
1659     */
1660    public static QueryColumn secToTime(QueryColumn columnS) {
1661        return new FunctionQueryColumn(SEC_TO_TIME, columnS);
1662    }
1663
1664    /**
1665     * 将以秒为单位的时间 s 转换为时分秒的格式。
1666     */
1667    public static <T> QueryColumn secToTime(LambdaGetter<T> columnS) {
1668        return new FunctionQueryColumn(SEC_TO_TIME, LambdaUtil.getQueryColumn(columnS));
1669    }
1670
1671    /**
1672     * 计算日期 d 到 0000 年 1 月 1 日的天数。
1673     */
1674    public static QueryColumn toDays(String columnD) {
1675        return new FunctionQueryColumn(TO_DAYS, columnD);
1676    }
1677
1678    /**
1679     * 计算日期 d 到 0000 年 1 月 1 日的天数。
1680     */
1681    public static QueryColumn toDays(QueryColumn columnD) {
1682        return new FunctionQueryColumn(TO_DAYS, columnD);
1683    }
1684
1685    /**
1686     * 计算日期 d 到 0000 年 1 月 1 日的天数。
1687     */
1688    public static <T> QueryColumn toDays(LambdaGetter<T> columnD) {
1689        return new FunctionQueryColumn(TO_DAYS, LambdaUtil.getQueryColumn(columnD));
1690    }
1691
1692    /**
1693     * 计算从 0000 年 1 月 1 日开始 n 天后的日期。
1694     */
1695    public static QueryColumn fromDays(String columnD) {
1696        return new FunctionQueryColumn(FROM_DAYS, columnD);
1697    }
1698
1699    /**
1700     * 计算从 0000 年 1 月 1 日开始 n 天后的日期。
1701     */
1702    public static QueryColumn fromDays(QueryColumn columnD) {
1703        return new FunctionQueryColumn(FROM_DAYS, columnD);
1704    }
1705
1706    /**
1707     * 计算从 0000 年 1 月 1 日开始 n 天后的日期。
1708     */
1709    public static <T> QueryColumn fromDays(LambdaGetter<T> columnD) {
1710        return new FunctionQueryColumn(FROM_DAYS, LambdaUtil.getQueryColumn(columnD));
1711    }
1712
1713    /**
1714     * 计算日期 d1 到 d2 之间相隔的天数。
1715     */
1716    public static QueryColumn dateDiff(String columnD1, String columnD2) {
1717        return new FunctionQueryColumn(DATEDIFF, columnD1, columnD2);
1718    }
1719
1720    /**
1721     * 计算日期 d1 到 d2 之间相隔的天数。
1722     */
1723    public static QueryColumn dateDiff(QueryColumn columnD1, QueryColumn columnD2) {
1724        return new FunctionQueryColumn(DATEDIFF, columnD1, columnD2);
1725    }
1726
1727    /**
1728     * 计算日期 d1 到 d2 之间相隔的天数。
1729     */
1730    public static <D1, D2> QueryColumn dateDiff(LambdaGetter<D1> columnD1, LambdaGetter<D2> columnD2) {
1731        return new FunctionQueryColumn(DATEDIFF, LambdaUtil.getQueryColumn(columnD1), LambdaUtil.getQueryColumn(columnD2));
1732    }
1733
1734    /**
1735     * 计算开始日期 d 加上 n 天的日期。
1736     */
1737    public static QueryColumn addDate(String columnD, String columnN) {
1738        return new FunctionQueryColumn(ADDDATE, columnD, columnN);
1739    }
1740
1741    /**
1742     * 计算开始日期 d 加上 n 天的日期。
1743     */
1744    public static QueryColumn addDate(QueryColumn columnD, QueryColumn columnN) {
1745        return new FunctionQueryColumn(ADDDATE, columnD, columnN);
1746    }
1747
1748    /**
1749     * 计算开始日期 d 加上 n 天的日期。
1750     */
1751    public static <D, N> QueryColumn addDate(LambdaGetter<D> columnD, LambdaGetter<N> columnN) {
1752        return new FunctionQueryColumn(ADDDATE, LambdaUtil.getQueryColumn(columnD), LambdaUtil.getQueryColumn(columnN));
1753    }
1754
1755    /**
1756     * 计算起始日期 d 减去 n 天的日期。
1757     */
1758    public static QueryColumn subDate(String columnD, String columnN) {
1759        return new FunctionQueryColumn(SUBDATE, columnD, columnN);
1760    }
1761
1762    /**
1763     * 计算起始日期 d 减去 n 天的日期。
1764     */
1765    public static QueryColumn subDate(QueryColumn columnD, QueryColumn columnN) {
1766        return new FunctionQueryColumn(SUBDATE, columnD, columnN);
1767    }
1768
1769    /**
1770     * 计算起始日期 d 减去 n 天的日期。
1771     */
1772    public static <D, N> QueryColumn subDate(LambdaGetter<D> columnD, LambdaGetter<N> columnN) {
1773        return new FunctionQueryColumn(SUBDATE, LambdaUtil.getQueryColumn(columnD), LambdaUtil.getQueryColumn(columnN));
1774    }
1775
1776    /**
1777     * 计算起始时间 t 加上 n 秒的时间。
1778     */
1779    public static QueryColumn addTime(String columnT, String columnN) {
1780        return new FunctionQueryColumn(ADDTIME, columnT, columnN);
1781    }
1782
1783    /**
1784     * 计算起始时间 t 加上 n 秒的时间。
1785     */
1786    public static QueryColumn addTime(QueryColumn columnT, QueryColumn columnN) {
1787        return new FunctionQueryColumn(ADDTIME, columnT, columnN);
1788    }
1789
1790    /**
1791     * 计算起始时间 t 加上 n 秒的时间。
1792     */
1793    public static <T, N> QueryColumn addTime(LambdaGetter<T> columnT, LambdaGetter<N> columnN) {
1794        return new FunctionQueryColumn(ADDTIME, LambdaUtil.getQueryColumn(columnT), LambdaUtil.getQueryColumn(columnN));
1795    }
1796
1797    /**
1798     * 计算起始时间 t 减去 n 秒的时间。
1799     */
1800    public static QueryColumn subTime(String columnT, String columnN) {
1801        return new FunctionQueryColumn(SUBTIME, columnT, columnN);
1802    }
1803
1804    /**
1805     * 计算起始时间 t 减去 n 秒的时间。
1806     */
1807    public static QueryColumn subTime(QueryColumn columnT, QueryColumn columnN) {
1808        return new FunctionQueryColumn(SUBTIME, columnT, columnN);
1809    }
1810
1811    /**
1812     * 计算起始时间 t 减去 n 秒的时间。
1813     */
1814    public static <T, N> QueryColumn subTime(LambdaGetter<T> columnT, LambdaGetter<N> columnN) {
1815        return new FunctionQueryColumn(SUBTIME, LambdaUtil.getQueryColumn(columnT), LambdaUtil.getQueryColumn(columnN));
1816    }
1817
1818    /**
1819     * 按照表达式 f 的要求显示日期 d。
1820     */
1821    public static QueryColumn dateFormat(String columnD, String format) {
1822        return new FunctionQueryColumn(DATE_FORMAT, string(columnD), string(format));
1823    }
1824
1825    /**
1826     * 按照表达式 f 的要求显示日期 d。
1827     */
1828    public static QueryColumn dateFormat(QueryColumn columnD, String format) {
1829        return new FunctionQueryColumn(DATE_FORMAT, columnD, string(format));
1830    }
1831
1832    /**
1833     * 按照表达式 f 的要求显示日期 d。
1834     */
1835    public static <D, F> QueryColumn dateFormat(LambdaGetter<D> columnD, String format) {
1836        return new FunctionQueryColumn(DATE_FORMAT, LambdaUtil.getQueryColumn(columnD), string(format));
1837    }
1838
1839    /**
1840     * 按照表达式 f 的要求显示时间 t。
1841     */
1842    public static QueryColumn timeFormat(String columnT, String columnF) {
1843        return new FunctionQueryColumn(TIME_FORMAT, columnT, columnF);
1844    }
1845
1846    /**
1847     * 按照表达式 f 的要求显示时间 t。
1848     */
1849    public static QueryColumn timeFormat(QueryColumn columnT, QueryColumn columnF) {
1850        return new FunctionQueryColumn(TIME_FORMAT, columnT, columnF);
1851    }
1852
1853    /**
1854     * 按照表达式 f 的要求显示时间 t。
1855     */
1856    public static <T, F> QueryColumn timeFormat(LambdaGetter<T> columnT, LambdaGetter<F> columnF) {
1857        return new FunctionQueryColumn(TIME_FORMAT, LambdaUtil.getQueryColumn(columnT), LambdaUtil.getQueryColumn(columnF));
1858    }
1859
1860    /**
1861     * 根据字符串 s 获取 type 类型数据的显示格式。
1862     */
1863    public static QueryColumn getFormat(String columnType, String columnS) {
1864        return new FunctionQueryColumn(GET_FORMAT, columnType, columnS);
1865    }
1866
1867    /**
1868     * 根据字符串 s 获取 type 类型数据的显示格式。
1869     */
1870    public static QueryColumn getFormat(QueryColumn columnType, QueryColumn columnS) {
1871        return new FunctionQueryColumn(GET_FORMAT, columnType, columnS);
1872    }
1873
1874    /**
1875     * 根据字符串 s 获取 type 类型数据的显示格式。
1876     */
1877    public static <T, S> QueryColumn getFormat(LambdaGetter<T> columnType, LambdaGetter<S> columnS) {
1878        return new FunctionQueryColumn(GET_FORMAT, LambdaUtil.getQueryColumn(columnType), LambdaUtil.getQueryColumn(columnS));
1879    }
1880
1881    // === 系统信息函数 ===
1882
1883    /**
1884     * 返回数据库的版本号。
1885     */
1886    public static QueryColumn version() {
1887        return new FunctionQueryColumn(VERSION);
1888    }
1889
1890    /**
1891     * 返回服务器的连接数。
1892     */
1893    public static QueryColumn connectionId() {
1894        return new FunctionQueryColumn(CONNECTION_ID);
1895    }
1896
1897    /**
1898     * 返回当前数据库名。
1899     */
1900    public static QueryColumn database() {
1901        return new FunctionQueryColumn(DATABASE);
1902    }
1903
1904    /**
1905     * 返回当前数据库 schema。
1906     */
1907    public static QueryColumn schema() {
1908        return new FunctionQueryColumn(SCHEMA);
1909    }
1910
1911    /**
1912     * 返回当前用户的名称。
1913     */
1914    public static QueryColumn user() {
1915        return new FunctionQueryColumn(USER);
1916    }
1917
1918    /**
1919     * 返回字符串 str 的字符集。
1920     */
1921    public static QueryColumn charset(String columnStr) {
1922        return new FunctionQueryColumn(CHARSET, columnStr);
1923    }
1924
1925    /**
1926     * 返回字符串 str 的字符集。
1927     */
1928    public static QueryColumn charset(QueryColumn columnStr) {
1929        return new FunctionQueryColumn(CHARSET, columnStr);
1930    }
1931
1932    /**
1933     * 返回字符串 str 的字符集。
1934     */
1935    public static <T> QueryColumn charset(LambdaGetter<T> columnStr) {
1936        return new FunctionQueryColumn(CHARSET, LambdaUtil.getQueryColumn(columnStr));
1937    }
1938
1939    /**
1940     * 返回字符串 str 的字符排列方式。
1941     */
1942    public static QueryColumn collation(String columnStr) {
1943        return new FunctionQueryColumn(COLLATION, columnStr);
1944    }
1945
1946    /**
1947     * 返回字符串 str 的字符排列方式。
1948     */
1949    public static QueryColumn collation(QueryColumn columnStr) {
1950        return new FunctionQueryColumn(COLLATION, columnStr);
1951    }
1952
1953    /**
1954     * 返回字符串 str 的字符排列方式。
1955     */
1956    public static <T> QueryColumn collation(LambdaGetter<T> columnStr) {
1957        return new FunctionQueryColumn(COLLATION, LambdaUtil.getQueryColumn(columnStr));
1958    }
1959
1960    /**
1961     * 返回最后生成的 auto_increment 值。
1962     */
1963    public static QueryColumn lastInsertId() {
1964        return new FunctionQueryColumn(LAST_INSERT_ID);
1965    }
1966
1967    // === 加密函数 ===
1968
1969    /**
1970     * 对字符串 str 进行加密。
1971     */
1972    public static QueryColumn password(String columnStr) {
1973        return new FunctionQueryColumn(PASSWORD, columnStr);
1974    }
1975
1976    /**
1977     * 对字符串 str 进行加密。
1978     */
1979    public static QueryColumn password(QueryColumn columnStr) {
1980        return new FunctionQueryColumn(PASSWORD, columnStr);
1981    }
1982
1983    /**
1984     * 对字符串 str 进行加密。
1985     */
1986    public static <T> QueryColumn password(LambdaGetter<T> columnStr) {
1987        return new FunctionQueryColumn(PASSWORD, LambdaUtil.getQueryColumn(columnStr));
1988    }
1989
1990    /**
1991     * 对字符串 str 进行加密。
1992     */
1993    public static QueryColumn md5(String columnStr) {
1994        return new FunctionQueryColumn(MD5, columnStr);
1995    }
1996
1997    /**
1998     * 对字符串 str 进行加密。
1999     */
2000    public static QueryColumn md5(QueryColumn columnStr) {
2001        return new FunctionQueryColumn(MD5, columnStr);
2002    }
2003
2004    /**
2005     * 对字符串 str 进行加密。
2006     */
2007    public static <T> QueryColumn md5(LambdaGetter<T> columnStr) {
2008        return new FunctionQueryColumn(MD5, LambdaUtil.getQueryColumn(columnStr));
2009    }
2010
2011    /**
2012     * 使用字符串 pswd_str 来加密字符串 str，加密结果是一个二进制数，必须使用 BLOB 类型来保持它。
2013     */
2014    public static QueryColumn encode(String columnStr, String columnPswdStr) {
2015        return new FunctionQueryColumn(ENCODE, columnStr, columnPswdStr);
2016    }
2017
2018    /**
2019     * 使用字符串 pswd_str 来加密字符串 str，加密结果是一个二进制数，必须使用 BLOB 类型来保持它。
2020     */
2021    public static QueryColumn encode(QueryColumn columnStr, QueryColumn columnPswdStr) {
2022        return new FunctionQueryColumn(ENCODE, columnStr, columnPswdStr);
2023    }
2024
2025    /**
2026     * 使用字符串 pswd_str 来加密字符串 str，加密结果是一个二进制数，必须使用 BLOB 类型来保持它。
2027     */
2028    public static <S, P> QueryColumn encode(LambdaGetter<S> columnStr, LambdaGetter<P> columnPswdStr) {
2029        return new FunctionQueryColumn(ENCODE, LambdaUtil.getQueryColumn(columnStr), LambdaUtil.getQueryColumn(columnPswdStr));
2030    }
2031
2032    /**
2033     * 解密函数，使用字符串 pswd_str 来为 crypt_str 解密。
2034     */
2035    public static QueryColumn decode(String columnCryptStr, String columnPswdStr) {
2036        return new FunctionQueryColumn(DECODE, columnCryptStr, columnPswdStr);
2037    }
2038
2039    /**
2040     * 解密函数，使用字符串 pswd_str 来为 crypt_str 解密。
2041     */
2042    public static QueryColumn decode(QueryColumn columnCryptStr, QueryColumn columnPswdStr) {
2043        return new FunctionQueryColumn(DECODE, columnCryptStr, columnPswdStr);
2044    }
2045
2046    /**
2047     * 解密函数，使用字符串 pswd_str 来为 crypt_str 解密。
2048     */
2049    public static <C, P> QueryColumn decode(LambdaGetter<C> columnCryptStr, LambdaGetter<P> columnPswdStr) {
2050        return new FunctionQueryColumn(DECODE, LambdaUtil.getQueryColumn(columnCryptStr), LambdaUtil.getQueryColumn(columnPswdStr));
2051    }
2052
2053    // === 其他函数 ===
2054
2055    /**
2056     * 格式化函数，可以将数字 x 进行格式化，将 x 保留到小数点后 n 位，这个过程需要进行四舍五入。
2057     */
2058    public static QueryColumn format(String columnX, String columnN) {
2059        return new FunctionQueryColumn(FORMAT, columnX, columnN);
2060    }
2061
2062    /**
2063     * 格式化函数，可以将数字 x 进行格式化，将 x 保留到小数点后 n 位，这个过程需要进行四舍五入。
2064     */
2065    public static QueryColumn format(QueryColumn columnX, QueryColumn columnN) {
2066        return new FunctionQueryColumn(FORMAT, columnX, columnN);
2067    }
2068
2069    /**
2070     * 格式化函数，可以将数字 x 进行格式化，将 x 保留到小数点后 n 位，这个过程需要进行四舍五入。
2071     */
2072    public static <X, N> QueryColumn format(LambdaGetter<X> columnX, LambdaGetter<N> columnN) {
2073        return new FunctionQueryColumn(FORMAT, LambdaUtil.getQueryColumn(columnX), LambdaUtil.getQueryColumn(columnN));
2074    }
2075
2076    /**
2077     * 返回字符串 s 的第一个字符的 ASSCII 码。
2078     */
2079    public static QueryColumn ascii(String columnS) {
2080        return new FunctionQueryColumn(ASCII, columnS);
2081    }
2082
2083    /**
2084     * 返回字符串 s 的第一个字符的 ASSCII 码。
2085     */
2086    public static QueryColumn ascii(QueryColumn columnS) {
2087        return new FunctionQueryColumn(ASCII, columnS);
2088    }
2089
2090    /**
2091     * 返回字符串 s 的第一个字符的 ASSCII 码。
2092     */
2093    public static <T> QueryColumn ascii(LambdaGetter<T> columnS) {
2094        return new FunctionQueryColumn(ASCII, LambdaUtil.getQueryColumn(columnS));
2095    }
2096
2097    /**
2098     * 返回 x 的二进制编码。
2099     */
2100    public static QueryColumn bin(String columnX) {
2101        return new FunctionQueryColumn(BIN, columnX);
2102    }
2103
2104    /**
2105     * 返回 x 的二进制编码。
2106     */
2107    public static QueryColumn bin(QueryColumn columnX) {
2108        return new FunctionQueryColumn(BIN, columnX);
2109    }
2110
2111    /**
2112     * 返回 x 的二进制编码。
2113     */
2114    public static <T> QueryColumn bin(LambdaGetter<T> columnX) {
2115        return new FunctionQueryColumn(BIN, LambdaUtil.getQueryColumn(columnX));
2116    }
2117
2118    /**
2119     * 返回 x 的十六进制编码。
2120     */
2121    public static QueryColumn hex(String columnX) {
2122        return new FunctionQueryColumn(HEX, columnX);
2123    }
2124
2125    /**
2126     * 返回 x 的十六进制编码。
2127     */
2128    public static QueryColumn hex(QueryColumn columnX) {
2129        return new FunctionQueryColumn(HEX, columnX);
2130    }
2131
2132    /**
2133     * 返回 x 的十六进制编码。
2134     */
2135    public static <T> QueryColumn hex(LambdaGetter<T> columnX) {
2136        return new FunctionQueryColumn(HEX, LambdaUtil.getQueryColumn(columnX));
2137    }
2138
2139    /**
2140     * 返回 x 的八进制编码。
2141     */
2142    public static QueryColumn oct(String columnX) {
2143        return new FunctionQueryColumn(OCT, columnX);
2144    }
2145
2146    /**
2147     * 返回 x 的八进制编码。
2148     */
2149    public static QueryColumn oct(QueryColumn columnX) {
2150        return new FunctionQueryColumn(OCT, columnX);
2151    }
2152
2153    /**
2154     * 返回 x 的八进制编码。
2155     */
2156    public static <T> QueryColumn oct(LambdaGetter<T> columnX) {
2157        return new FunctionQueryColumn(OCT, LambdaUtil.getQueryColumn(columnX));
2158    }
2159
2160    /**
2161     * 将 x 从 f1 进制数变成 f2 进制数。
2162     */
2163    public static QueryColumn conv(String columnX, String columnF1, String columnF2) {
2164        return new FunctionQueryColumn(CONV, columnX, columnF1, columnF2);
2165    }
2166
2167    /**
2168     * 将 x 从 f1 进制数变成 f2 进制数。
2169     */
2170    public static QueryColumn conv(QueryColumn columnX, QueryColumn columnF1, QueryColumn columnF2) {
2171        return new FunctionQueryColumn(CONV, columnX, columnF1, columnF2);
2172    }
2173
2174    /**
2175     * 将 x 从 f1 进制数变成 f2 进制数。
2176     */
2177    public static <X, F1, F2> QueryColumn conv(LambdaGetter<X> columnX, LambdaGetter<F1> columnF1, LambdaGetter<F2> columnF2) {
2178        return new FunctionQueryColumn(CONV, LambdaUtil.getQueryColumn(columnX), LambdaUtil.getQueryColumn(columnF1), LambdaUtil.getQueryColumn(columnF2));
2179    }
2180
2181    /**
2182     * 将 IP 地址转换为数字表示，IP 值需要加上引号。
2183     */
2184    public static QueryColumn inetAton(String columnIP) {
2185        return new FunctionQueryColumn(INET_ATON, columnIP);
2186    }
2187
2188    /**
2189     * 将 IP 地址转换为数字表示，IP 值需要加上引号。
2190     */
2191    public static QueryColumn inetAton(QueryColumn columnIP) {
2192        return new FunctionQueryColumn(INET_ATON, columnIP);
2193    }
2194
2195    /**
2196     * 将 IP 地址转换为数字表示，IP 值需要加上引号。
2197     */
2198    public static <T> QueryColumn inetAton(LambdaGetter<T> columnIP) {
2199        return new FunctionQueryColumn(INET_ATON, LambdaUtil.getQueryColumn(columnIP));
2200    }
2201
2202    /**
2203     * 可以将数字 n 转换成 IP 的形式。
2204     */
2205    public static QueryColumn inetNtoa(String columnN) {
2206        return new FunctionQueryColumn(INET_NTOA, columnN);
2207    }
2208
2209    /**
2210     * 可以将数字 n 转换成 IP 的形式。
2211     */
2212    public static QueryColumn inetNtoa(QueryColumn columnN) {
2213        return new FunctionQueryColumn(INET_NTOA, columnN);
2214    }
2215
2216    /**
2217     * 可以将数字 n 转换成 IP 的形式。
2218     */
2219    public static <T> QueryColumn inetNtoa(LambdaGetter<T> columnN) {
2220        return new FunctionQueryColumn(INET_NTOA, LambdaUtil.getQueryColumn(columnN));
2221    }
2222
2223    // === 聚合函数 ===
2224
2225    /**
2226     * 返回指定列的最大值。
2227     */
2228    public static FunctionQueryColumn max(String column) {
2229        return new FunctionQueryColumn(MAX, column);
2230    }
2231
2232    /**
2233     * 返回指定列的最大值。
2234     */
2235    public static FunctionQueryColumn max(QueryColumn column) {
2236        return new FunctionQueryColumn(MAX, column);
2237    }
2238
2239    /**
2240     * 返回指定列的最大值。
2241     */
2242    public static <T> FunctionQueryColumn max(LambdaGetter<T> column) {
2243        return new FunctionQueryColumn(MAX, LambdaUtil.getQueryColumn(column));
2244    }
2245
2246    /**
2247     * 返回指定列的最小值。
2248     */
2249    public static FunctionQueryColumn min(String column) {
2250        return new FunctionQueryColumn(MIN, column);
2251    }
2252
2253    /**
2254     * 返回指定列的最小值。
2255     */
2256    public static FunctionQueryColumn min(QueryColumn column) {
2257        return new FunctionQueryColumn(MIN, column);
2258    }
2259
2260    /**
2261     * 返回指定列的最小值。
2262     */
2263    public static <T> FunctionQueryColumn min(LambdaGetter<T> column) {
2264        return new FunctionQueryColumn(MIN, LambdaUtil.getQueryColumn(column));
2265    }
2266
2267    /**
2268     * 返回指定列的平均值。
2269     */
2270    public static FunctionQueryColumn avg(String column) {
2271        return new FunctionQueryColumn(AVG, column);
2272    }
2273
2274    /**
2275     * 返回指定列的平均值。
2276     */
2277    public static FunctionQueryColumn avg(QueryColumn column) {
2278        return new FunctionQueryColumn(AVG, column);
2279    }
2280
2281    /**
2282     * 返回指定列的平均值。
2283     */
2284    public static <T> FunctionQueryColumn avg(LambdaGetter<T> column) {
2285        return new FunctionQueryColumn(AVG, LambdaUtil.getQueryColumn(column));
2286    }
2287
2288    /**
2289     * 返回指定字段值的和。
2290     */
2291    public static FunctionQueryColumn sum(String column) {
2292        return new FunctionQueryColumn(SUM, column);
2293    }
2294
2295    /**
2296     * 返回指定字段值的和。
2297     */
2298    public static FunctionQueryColumn sum(QueryColumn column) {
2299        return new FunctionQueryColumn(SUM, column);
2300    }
2301
2302    /**
2303     * 返回指定字段值的和。
2304     */
2305    public static <T> FunctionQueryColumn sum(LambdaGetter<T> column) {
2306        return new FunctionQueryColumn(SUM, LambdaUtil.getQueryColumn(column));
2307    }
2308
2309    // === COUNT ===
2310
2311    /**
2312     * 返回指定列的总行数。
2313     */
2314    public static FunctionQueryColumn count() {
2315        return new FunctionQueryColumn(COUNT, new RawQueryColumn("*"));
2316    }
2317
2318    /**
2319     * 返回指定列的总行数。
2320     */
2321    public static FunctionQueryColumn count(String column) {
2322        return new FunctionQueryColumn(COUNT, column);
2323    }
2324
2325    /**
2326     * 返回指定列的总行数。
2327     */
2328    public static FunctionQueryColumn count(QueryColumn column) {
2329        return new FunctionQueryColumn(COUNT, column);
2330    }
2331
2332    /**
2333     * 返回指定列的总行数。
2334     */
2335    public static <T> FunctionQueryColumn count(LambdaGetter<T> column) {
2336        return new FunctionQueryColumn(COUNT, LambdaUtil.getQueryColumn(column));
2337    }
2338
2339
2340    // === DISTINCT ===
2341
2342    /**
2343     * 对指定列进行去重。
2344     */
2345    public static DistinctQueryColumn distinct(QueryColumn... columns) {
2346        return new DistinctQueryColumn(columns);
2347    }
2348
2349    // === CASE THEN ELSE ===
2350
2351    /**
2352     * 构建 case then when 语句。
2353     */
2354    public static CaseQueryColumn.Builder case_() {
2355        return new CaseQueryColumn.Builder();
2356    }
2357
2358    /**
2359     * 构建 case then when 语句。
2360     */
2361    public static CaseSearchQueryColumn.Builder case_(QueryColumn column) {
2362        return new CaseSearchQueryColumn.Builder(column);
2363    }
2364
2365    // === CONVERT ===
2366
2367    /**
2368     * 将所给类型类型转换为另一种类型。
2369     */
2370    public static StringFunctionQueryColumn convert(String... params) {
2371        return new StringFunctionQueryColumn(CONVERT, params);
2372    }
2373
2374    // === 构建 column 列 ===
2375
2376    /**
2377     * 构建 TRUE 常量。
2378     */
2379    public static QueryColumn true_() {
2380        return new RawQueryColumn("TRUE");
2381    }
2382
2383    /**
2384     * 构建 FALSE 常量。
2385     */
2386    public static QueryColumn false_() {
2387        return new RawQueryColumn("FALSE");
2388    }
2389
2390    /**
2391     * 构建 NULL 常量。
2392     */
2393    public static QueryColumn null_() {
2394        return new RawQueryColumn("NULL");
2395    }
2396
2397    /**
2398     * 构建数字常量。
2399     */
2400    public static QueryColumn number(Number n) {
2401        return new RawQueryColumn(n);
2402    }
2403
2404    /**
2405     * 构建数字常量。
2406     */
2407    public static QueryColumn string(String s) {
2408        return new RawQueryColumn("'" + s + "'");
2409    }
2410
2411    /**
2412     * 构建相反数。
2413     */
2414    public static QueryColumn negative(QueryColumn queryColumn) {
2415        return new NegativeQueryColumn(queryColumn);
2416    }
2417
2418    /**
2419     * 构建自定义列。
2420     */
2421    public static QueryColumn column(String column, Object... params) {
2422        return new RawQueryColumn(column, params);
2423    }
2424
2425    /**
2426     * 构建自定义列。
2427     */
2428    public static QueryColumn column(String table, String column) {
2429        return new QueryColumn(table, column);
2430    }
2431
2432    /**
2433     * 构建自定义列。
2434     */
2435    public static QueryColumn column(String schema, String table, String column) {
2436        return new QueryColumn(schema, table, column);
2437    }
2438
2439    /**
2440     * 构建自定义列。
2441     */
2442    public static <T> QueryColumn column(LambdaGetter<T> column) {
2443        return LambdaUtil.getQueryColumn(column);
2444    }
2445
2446    /**
2447     * 构建自定义列。
2448     */
2449    public static QueryColumn column(QueryWrapper queryWrapper) {
2450        return new SelectQueryColumn(queryWrapper);
2451    }
2452
2453    /**
2454     * 构建所有列。
2455     */
2456    public static QueryColumn allColumns() {
2457        return column("*");
2458    }
2459
2460    /**
2461     * 构建所有列。
2462     */
2463    public static Iterable<QueryColumn> allColumns(Class<?>... classes) {
2464        List<QueryColumn> queryColumns = new ArrayList<>(classes.length);
2465        for (Class<?> aClass : classes) {
2466            TableInfo tableInfo = TableInfoFactory.ofEntityClass(aClass);
2467            QueryTable queryTable = new QueryTable(tableInfo.getSchema(), tableInfo.getTableName());
2468            queryColumns.add(new QueryColumn(queryTable, "*"));
2469        }
2470        return queryColumns;
2471    }
2472
2473    /**
2474     * 构建默认列。
2475     */
2476    public static Iterable<QueryColumn> defaultColumns(Class<?>... classes) {
2477        List<QueryColumn> queryColumns = new ArrayList<>();
2478        for (Class<?> aClass : classes) {
2479            TableInfo tableInfo = TableInfoFactory.ofEntityClass(aClass);
2480            queryColumns.addAll(tableInfo.getDefaultQueryColumn());
2481        }
2482        return queryColumns;
2483    }
2484
2485    // === IF 函数 ===
2486
2487    /**
2488     * IF 函数。
2489     */
2490    public static QueryColumn if_(QueryCondition condition, String trueColumn, String falseColumn) {
2491        return new IfFunctionQueryColumn(condition, new QueryColumn(trueColumn), new QueryColumn(falseColumn));
2492    }
2493
2494    /**
2495     * IF 函数。
2496     */
2497    public static QueryColumn if_(QueryCondition condition, QueryColumn trueColumn, QueryColumn falseColumn) {
2498        return new IfFunctionQueryColumn(condition, trueColumn, falseColumn);
2499    }
2500
2501    /**
2502     * IF 函数。
2503     */
2504    public static <T, F> QueryColumn if_(QueryCondition condition, LambdaGetter<T> trueColumn, LambdaGetter<F> falseColumn) {
2505        return new IfFunctionQueryColumn(condition, LambdaUtil.getQueryColumn(trueColumn), LambdaUtil.getQueryColumn(falseColumn));
2506    }
2507
2508    /**
2509     * IFNULL 函数。
2510     */
2511    public static QueryColumn ifNull(String nullColumn, String elseColumn) {
2512        return new FunctionQueryColumn("IFNULL", new QueryColumn(nullColumn), new QueryColumn(elseColumn));
2513    }
2514
2515    /**
2516     * IFNULL 函数。
2517     */
2518    public static QueryColumn ifNull(QueryColumn nullColumn, QueryColumn elseColumn) {
2519        return new FunctionQueryColumn("IFNULL", nullColumn, elseColumn);
2520    }
2521
2522    /**
2523     * IFNULL 函数。
2524     */
2525    public static <N, E> QueryColumn ifNull(LambdaGetter<N> nullColumn, LambdaGetter<E> elseColumn) {
2526        return new FunctionQueryColumn("IFNULL", LambdaUtil.getQueryColumn(nullColumn), LambdaUtil.getQueryColumn(elseColumn));
2527    }
2528
2529    /**
2530     * IFNULL 函数。
2531     */
2532    public static <N> QueryColumn ifNull(LambdaGetter<N> nullColumn, QueryColumn elseColumn) {
2533        return ifNull(LambdaUtil.getQueryColumn(nullColumn), elseColumn);
2534    }
2535
2536    /**
2537     * IFNULL 函数。
2538     */
2539    public static <N> QueryColumn ifNull(LambdaGetter<N> nullColumn, String elseColumn) {
2540        return ifNull(nullColumn, new QueryColumn(elseColumn));
2541    }
2542
2543
2544    // === 构建 QueryCondition 查询条件 ===
2545
2546    /**
2547     * EXIST (SELECT ...)
2548     */
2549    public static QueryCondition exists(QueryWrapper queryWrapper) {
2550        return new OperatorSelectCondition("EXISTS ", queryWrapper);
2551    }
2552
2553    /**
2554     * NOT EXIST (SELECT ...)
2555     */
2556    public static QueryCondition notExists(QueryWrapper queryWrapper) {
2557        return new OperatorSelectCondition("NOT EXISTS ", queryWrapper);
2558    }
2559
2560    /**
2561     * NOT (id = 1)
2562     */
2563    public static QueryCondition not(QueryCondition childCondition) {
2564        return new OperatorQueryCondition("NOT ", childCondition);
2565    }
2566
2567    /**
2568     * 空条件。
2569     */
2570    public static QueryCondition noCondition() {
2571        return QueryCondition.createEmpty();
2572    }
2573
2574    /**
2575     * 括号条件。
2576     */
2577    public static QueryCondition bracket(QueryCondition condition) {
2578        return new Brackets(condition);
2579    }
2580
2581    // === 构建 QueryWrapper 查询 ===
2582
2583    /**
2584     * SELECT queryColumns FROM table
2585     */
2586    public static QueryWrapper select(QueryColumn... queryColumns) {
2587        return newWrapper().select(queryColumns);
2588    }
2589
2590    /**
2591     * SELECT * FROM table UNION SELECT ...
2592     */
2593    public static QueryWrapper union(QueryWrapper queryWrapper) {
2594        return newWrapper().union(queryWrapper);
2595    }
2596
2597    /**
2598     * SELECT 1 FROM table
2599     */
2600    public static QueryWrapper selectOne() {
2601        return select(column("1"));
2602    }
2603
2604    /**
2605     * SELECT COUNT(*) FROM table
2606     */
2607    public static QueryWrapper selectCount() {
2608        return select(count());
2609    }
2610
2611    /**
2612     * SELECT COUNT(1) FROM table
2613     */
2614    public static QueryWrapper selectCountOne() {
2615        return select(count("1"));
2616    }
2617
2618    /**
2619     * SELECT * FROM table
2620     */
2621    private static QueryWrapper newWrapper() {
2622        return new QueryWrapper();
2623    }
2624
2625    // 构建原生 SQL 条件
2626
2627    /**
2628     * 构建原生查询条件。
2629     */
2630    public static QueryCondition raw(String raw) {
2631        return new RawQueryCondition(raw);
2632    }
2633
2634    /**
2635     * 构建原生查询条件，并附带参数。
2636     */
2637    public static QueryCondition raw(String raw, Object... params) {
2638        return new RawQueryCondition(raw, params);
2639    }
2640
2641
2642    /**
2643     * 分组值拼接
2644     */
2645    public static QueryColumn groupConcat(QueryColumn columnX) {
2646        return new FunctionQueryColumn(GROUP_CONCAT, columnX);
2647    }
2648
2649}