gluesql_core/ast_builder/expr/
function.rs

1use crate::{
2    ast::{DateTimeField, Function},
3    ast_builder::{DataTypeNode, ExprList, ExprNode},
4    result::{Error, Result},
5};
6
7#[derive(Clone, Debug)]
8pub enum FunctionNode<'a> {
9    Abs(ExprNode<'a>),
10    Upper(ExprNode<'a>),
11    IfNull {
12        expr: ExprNode<'a>,
13        then: ExprNode<'a>,
14    },
15    NullIf {
16        expr1: ExprNode<'a>,
17        expr2: ExprNode<'a>,
18    },
19    Ceil(ExprNode<'a>),
20    Rand(Option<ExprNode<'a>>),
21    Round(ExprNode<'a>),
22    Trunc(ExprNode<'a>),
23    Floor(ExprNode<'a>),
24    Asin(ExprNode<'a>),
25    Acos(ExprNode<'a>),
26    Atan(ExprNode<'a>),
27    Sin(ExprNode<'a>),
28    Cos(ExprNode<'a>),
29    Tan(ExprNode<'a>),
30    Pi,
31    Now,
32    CurrentDate,
33    CurrentTime,
34    CurrentTimestamp,
35    Left {
36        expr: ExprNode<'a>,
37        size: ExprNode<'a>,
38    },
39    Log {
40        antilog: ExprNode<'a>,
41        base: ExprNode<'a>,
42    },
43    Log2(ExprNode<'a>),
44    Log10(ExprNode<'a>),
45    Ln(ExprNode<'a>),
46    Right {
47        expr: ExprNode<'a>,
48        size: ExprNode<'a>,
49    },
50    Reverse(ExprNode<'a>),
51    Sign(ExprNode<'a>),
52    Power {
53        expr: ExprNode<'a>,
54        power: ExprNode<'a>,
55    },
56    Sqrt(ExprNode<'a>),
57    Skip {
58        expr: ExprNode<'a>,
59        size: ExprNode<'a>,
60    },
61    Gcd {
62        left: ExprNode<'a>,
63        right: ExprNode<'a>,
64    },
65    Lcm {
66        left: ExprNode<'a>,
67        right: ExprNode<'a>,
68    },
69    GenerateUuid,
70    Repeat {
71        expr: ExprNode<'a>,
72        num: ExprNode<'a>,
73    },
74    Replace {
75        expr: ExprNode<'a>,
76        old: ExprNode<'a>,
77        new: ExprNode<'a>,
78    },
79    Exp(ExprNode<'a>),
80    Lpad {
81        expr: ExprNode<'a>,
82        size: ExprNode<'a>,
83        fill: Option<ExprNode<'a>>,
84    },
85    Rpad {
86        expr: ExprNode<'a>,
87        size: ExprNode<'a>,
88        fill: Option<ExprNode<'a>>,
89    },
90    Degrees(ExprNode<'a>),
91    Radians(ExprNode<'a>),
92    Coalesce(ExprList<'a>),
93    Concat(ExprList<'a>),
94    ConcatWs {
95        separator: ExprNode<'a>,
96        exprs: ExprList<'a>,
97    },
98    Take {
99        expr: ExprNode<'a>,
100        size: ExprNode<'a>,
101    },
102    Substr {
103        expr: ExprNode<'a>,
104        start: ExprNode<'a>,
105        count: Option<ExprNode<'a>>,
106    },
107    Ltrim {
108        expr: ExprNode<'a>,
109        chars: Option<ExprNode<'a>>,
110    },
111    Rtrim {
112        expr: ExprNode<'a>,
113        chars: Option<ExprNode<'a>>,
114    },
115    Div {
116        dividend: ExprNode<'a>,
117        divisor: ExprNode<'a>,
118    },
119    Mod {
120        dividend: ExprNode<'a>,
121        divisor: ExprNode<'a>,
122    },
123    Format {
124        expr: ExprNode<'a>,
125        format: ExprNode<'a>,
126    },
127    ToDate {
128        expr: ExprNode<'a>,
129        format: ExprNode<'a>,
130    },
131    ToTimestamp {
132        expr: ExprNode<'a>,
133        format: ExprNode<'a>,
134    },
135    ToTime {
136        expr: ExprNode<'a>,
137        format: ExprNode<'a>,
138    },
139    Lower(ExprNode<'a>),
140    Initcap(ExprNode<'a>),
141    Position {
142        from_expr: ExprNode<'a>,
143        sub_expr: ExprNode<'a>,
144    },
145    FindIdx {
146        from_expr: ExprNode<'a>,
147        sub_expr: ExprNode<'a>,
148        start: Option<ExprNode<'a>>,
149    },
150    Cast {
151        expr: ExprNode<'a>,
152        data_type: DataTypeNode,
153    },
154    Extract {
155        field: DateTimeField,
156        expr: ExprNode<'a>,
157    },
158    Ascii(ExprNode<'a>),
159    Chr(ExprNode<'a>),
160    Md5(ExprNode<'a>),
161    Hex(ExprNode<'a>),
162    Point {
163        x: ExprNode<'a>,
164        y: ExprNode<'a>,
165    },
166    GetX(ExprNode<'a>),
167    GetY(ExprNode<'a>),
168    Greatest(ExprList<'a>),
169    CalcDistance {
170        geometry1: ExprNode<'a>,
171        geometry2: ExprNode<'a>,
172    },
173    Length(ExprNode<'a>),
174    IsEmpty(ExprNode<'a>),
175    LastDay(ExprNode<'a>),
176    Entries(ExprNode<'a>),
177    Keys(ExprNode<'a>),
178    Values(ExprNode<'a>),
179}
180
181impl<'a> TryFrom<FunctionNode<'a>> for Function {
182    type Error = Error;
183
184    fn try_from(func_node: FunctionNode<'a>) -> Result<Self> {
185        match func_node {
186            FunctionNode::Abs(expr_node) => expr_node.try_into().map(Function::Abs),
187            FunctionNode::Upper(expr_node) => expr_node.try_into().map(Function::Upper),
188            FunctionNode::Lower(expr_node) => expr_node.try_into().map(Function::Lower),
189            FunctionNode::Initcap(expr_node) => expr_node.try_into().map(Function::Initcap),
190            FunctionNode::IfNull { expr, then } => {
191                let expr = expr.try_into()?;
192                let then = then.try_into()?;
193                Ok(Function::IfNull { expr, then })
194            }
195            FunctionNode::NullIf { expr1, expr2 } => {
196                let expr1 = expr1.try_into()?;
197                let expr2 = expr2.try_into()?;
198                Ok(Function::NullIf { expr1, expr2 })
199            }
200            FunctionNode::Ceil(expr_node) => expr_node.try_into().map(Function::Ceil),
201            FunctionNode::Rand(expr_node) => Ok(Function::Rand(
202                expr_node.map(TryInto::try_into).transpose()?,
203            )),
204            FunctionNode::Round(expr_node) => expr_node.try_into().map(Function::Round),
205            FunctionNode::Trunc(expr_node) => expr_node.try_into().map(Function::Trunc),
206            FunctionNode::Floor(expr_node) => expr_node.try_into().map(Function::Floor),
207            FunctionNode::Asin(expr_node) => expr_node.try_into().map(Function::Asin),
208            FunctionNode::Acos(expr_node) => expr_node.try_into().map(Function::Acos),
209            FunctionNode::Atan(expr_node) => expr_node.try_into().map(Function::Atan),
210            FunctionNode::Sin(expr_node) => expr_node.try_into().map(Function::Sin),
211            FunctionNode::Cos(expr_node) => expr_node.try_into().map(Function::Cos),
212            FunctionNode::Tan(expr_node) => expr_node.try_into().map(Function::Tan),
213            FunctionNode::Pi => Ok(Function::Pi()),
214            FunctionNode::Now => Ok(Function::Now()),
215            FunctionNode::CurrentDate => Ok(Function::CurrentDate()),
216            FunctionNode::CurrentTime => Ok(Function::CurrentTime()),
217            FunctionNode::CurrentTimestamp => Ok(Function::CurrentTimestamp()),
218            FunctionNode::Left { expr, size } => {
219                let expr = expr.try_into()?;
220                let size = size.try_into()?;
221                Ok(Function::Left { expr, size })
222            }
223            FunctionNode::Log { antilog, base } => {
224                let antilog = antilog.try_into()?;
225                let base = base.try_into()?;
226                Ok(Function::Log { antilog, base })
227            }
228            FunctionNode::Log2(expr_node) => expr_node.try_into().map(Function::Log2),
229            FunctionNode::Log10(expr_node) => expr_node.try_into().map(Function::Log10),
230            FunctionNode::Ln(expr_node) => expr_node.try_into().map(Function::Ln),
231            FunctionNode::Right { expr, size } => {
232                let expr = expr.try_into()?;
233                let size = size.try_into()?;
234                Ok(Function::Right { expr, size })
235            }
236            FunctionNode::Reverse(expr_node) => expr_node.try_into().map(Function::Reverse),
237            FunctionNode::Sign(expr_node) => expr_node.try_into().map(Function::Sign),
238            FunctionNode::Power { expr, power } => {
239                let expr = expr.try_into()?;
240                let power = power.try_into()?;
241                Ok(Function::Power { expr, power })
242            }
243            FunctionNode::Sqrt(expr_node) => expr_node.try_into().map(Function::Sqrt),
244            FunctionNode::Skip { expr, size } => {
245                let expr = expr.try_into()?;
246                let size = size.try_into()?;
247                Ok(Function::Skip { expr, size })
248            }
249            FunctionNode::Gcd { left, right } => {
250                let left = left.try_into()?;
251                let right = right.try_into()?;
252                Ok(Function::Gcd { left, right })
253            }
254            FunctionNode::Lcm { left, right } => {
255                let left = left.try_into()?;
256                let right = right.try_into()?;
257                Ok(Function::Lcm { left, right })
258            }
259            FunctionNode::GenerateUuid => Ok(Function::GenerateUuid()),
260            FunctionNode::Repeat { expr, num } => {
261                let expr = expr.try_into()?;
262                let num = num.try_into()?;
263                Ok(Function::Repeat { expr, num })
264            }
265            FunctionNode::Replace { expr, old, new } => {
266                let expr = expr.try_into()?;
267                let old = old.try_into()?;
268                let new = new.try_into()?;
269                Ok(Function::Replace { expr, old, new })
270            }
271            FunctionNode::Lpad { expr, size, fill } => {
272                let fill = fill.map(TryInto::try_into).transpose()?;
273                let expr = expr.try_into()?;
274                let size = size.try_into()?;
275                Ok(Function::Lpad { expr, size, fill })
276            }
277            FunctionNode::Rpad { expr, size, fill } => {
278                let fill = fill.map(TryInto::try_into).transpose()?;
279                let expr = expr.try_into()?;
280                let size = size.try_into()?;
281                Ok(Function::Rpad { expr, size, fill })
282            }
283            FunctionNode::Coalesce(expr_list) => expr_list.try_into().map(Function::Coalesce),
284            FunctionNode::Concat(expr_list) => expr_list.try_into().map(Function::Concat),
285            FunctionNode::ConcatWs { separator, exprs } => {
286                let separator = separator.try_into()?;
287                let exprs = exprs.try_into()?;
288                Ok(Function::ConcatWs { separator, exprs })
289            }
290            FunctionNode::Take { expr, size } => {
291                let expr = expr.try_into()?;
292                let size = size.try_into()?;
293                Ok(Function::Take { expr, size })
294            }
295            FunctionNode::Degrees(expr) => expr.try_into().map(Function::Degrees),
296            FunctionNode::Radians(expr) => expr.try_into().map(Function::Radians),
297            FunctionNode::Exp(expr) => expr.try_into().map(Function::Exp),
298            FunctionNode::Substr { expr, start, count } => {
299                let count = count.map(TryInto::try_into).transpose()?;
300                let expr = expr.try_into()?;
301                let start = start.try_into()?;
302                Ok(Function::Substr { expr, start, count })
303            }
304            FunctionNode::Ltrim { expr, chars } => {
305                let chars = chars.map(TryInto::try_into).transpose()?;
306                let expr = expr.try_into()?;
307                Ok(Function::Ltrim { expr, chars })
308            }
309            FunctionNode::Rtrim { expr, chars } => {
310                let chars = chars.map(TryInto::try_into).transpose()?;
311                let expr = expr.try_into()?;
312                Ok(Function::Rtrim { expr, chars })
313            }
314            FunctionNode::Div { dividend, divisor } => {
315                let dividend = dividend.try_into()?;
316                let divisor = divisor.try_into()?;
317                Ok(Function::Div { dividend, divisor })
318            }
319            FunctionNode::Mod { dividend, divisor } => {
320                let dividend = dividend.try_into()?;
321                let divisor = divisor.try_into()?;
322                Ok(Function::Mod { dividend, divisor })
323            }
324            FunctionNode::Format { expr, format } => {
325                let expr = expr.try_into()?;
326                let format = format.try_into()?;
327                Ok(Function::Format { expr, format })
328            }
329            FunctionNode::ToDate { expr, format } => {
330                let expr = expr.try_into()?;
331                let format = format.try_into()?;
332                Ok(Function::ToDate { expr, format })
333            }
334            FunctionNode::ToTimestamp { expr, format } => {
335                let expr = expr.try_into()?;
336                let format = format.try_into()?;
337                Ok(Function::ToTimestamp { expr, format })
338            }
339            FunctionNode::ToTime { expr, format } => {
340                let expr = expr.try_into()?;
341                let format = format.try_into()?;
342                Ok(Function::ToTime { expr, format })
343            }
344            FunctionNode::Position {
345                from_expr,
346                sub_expr,
347            } => {
348                let from_expr = from_expr.try_into()?;
349                let sub_expr = sub_expr.try_into()?;
350                Ok(Function::Position {
351                    from_expr,
352                    sub_expr,
353                })
354            }
355            FunctionNode::FindIdx {
356                from_expr,
357                sub_expr,
358                start,
359            } => {
360                let from_expr = from_expr.try_into()?;
361                let sub_expr = sub_expr.try_into()?;
362                let start = start.map(TryInto::try_into).transpose()?;
363                Ok(Function::FindIdx {
364                    from_expr,
365                    sub_expr,
366                    start,
367                })
368            }
369            FunctionNode::Cast { expr, data_type } => {
370                let expr = expr.try_into()?;
371                let data_type = data_type.try_into()?;
372                Ok(Function::Cast { expr, data_type })
373            }
374            FunctionNode::Extract { field, expr } => {
375                let expr = expr.try_into()?;
376                Ok(Function::Extract { field, expr })
377            }
378            FunctionNode::Ascii(expr) => expr.try_into().map(Function::Ascii),
379            FunctionNode::Chr(expr) => expr.try_into().map(Function::Chr),
380            FunctionNode::Md5(expr) => expr.try_into().map(Function::Md5),
381            FunctionNode::Hex(expr) => expr.try_into().map(Function::Hex),
382            FunctionNode::Point { x, y } => {
383                let x = x.try_into()?;
384                let y = y.try_into()?;
385                Ok(Function::Point { x, y })
386            }
387            FunctionNode::GetX(expr) => expr.try_into().map(Function::GetX),
388            FunctionNode::GetY(expr) => expr.try_into().map(Function::GetY),
389            FunctionNode::Greatest(expr_list) => expr_list.try_into().map(Function::Greatest),
390            FunctionNode::CalcDistance {
391                geometry1,
392                geometry2,
393            } => {
394                let geometry1 = geometry1.try_into()?;
395                let geometry2 = geometry2.try_into()?;
396                Ok(Function::CalcDistance {
397                    geometry1,
398                    geometry2,
399                })
400            }
401            FunctionNode::Length(expr) => expr.try_into().map(Function::Length),
402            FunctionNode::IsEmpty(expr) => expr.try_into().map(Function::IsEmpty),
403            FunctionNode::LastDay(expr) => expr.try_into().map(Function::LastDay),
404            FunctionNode::Entries(expr) => expr.try_into().map(Function::Entries),
405            FunctionNode::Keys(expr) => expr.try_into().map(Function::Keys),
406            FunctionNode::Values(expr) => expr.try_into().map(Function::Values),
407        }
408    }
409}
410
411impl<'a> ExprNode<'a> {
412    #[must_use]
413    pub fn abs(self) -> ExprNode<'a> {
414        abs(self)
415    }
416    #[must_use]
417    pub fn upper(self) -> ExprNode<'a> {
418        upper(self)
419    }
420    #[must_use]
421    pub fn lower(self) -> ExprNode<'a> {
422        lower(self)
423    }
424    #[must_use]
425    pub fn initcap(self) -> ExprNode<'a> {
426        initcap(self)
427    }
428    #[must_use]
429    pub fn ifnull<T: Into<ExprNode<'a>>>(self, another: T) -> ExprNode<'a> {
430        ifnull(self, another)
431    }
432    #[must_use]
433    pub fn nullif<T: Into<ExprNode<'a>>>(self, another: T) -> ExprNode<'a> {
434        nullif(self, another)
435    }
436    #[must_use]
437    pub fn ceil(self) -> ExprNode<'a> {
438        ceil(self)
439    }
440    #[must_use]
441    pub fn rand(self) -> ExprNode<'a> {
442        rand(Some(self))
443    }
444    #[must_use]
445    pub fn round(self) -> ExprNode<'a> {
446        round(self)
447    }
448    #[must_use]
449    pub fn trunc(self) -> ExprNode<'a> {
450        trunc(self)
451    }
452    #[must_use]
453    pub fn floor(self) -> ExprNode<'a> {
454        floor(self)
455    }
456    #[must_use]
457    pub fn asin(self) -> ExprNode<'a> {
458        asin(self)
459    }
460    #[must_use]
461    pub fn acos(self) -> ExprNode<'a> {
462        acos(self)
463    }
464    #[must_use]
465    pub fn atan(self) -> ExprNode<'a> {
466        atan(self)
467    }
468    #[must_use]
469    pub fn sin(self) -> ExprNode<'a> {
470        sin(self)
471    }
472    #[must_use]
473    pub fn cos(self) -> ExprNode<'a> {
474        cos(self)
475    }
476    #[must_use]
477    pub fn tan(self) -> ExprNode<'a> {
478        tan(self)
479    }
480    #[must_use]
481    pub fn left<T: Into<ExprNode<'a>>>(self, size: T) -> Self {
482        left(self, size)
483    }
484    #[must_use]
485    pub fn log<T: Into<ExprNode<'a>>>(self, base: T) -> ExprNode<'a> {
486        log(self, base)
487    }
488    #[must_use]
489    pub fn log2(self) -> ExprNode<'a> {
490        log2(self)
491    }
492    #[must_use]
493    pub fn log10(self) -> ExprNode<'a> {
494        log10(self)
495    }
496    #[must_use]
497    pub fn ln(self) -> ExprNode<'a> {
498        ln(self)
499    }
500    #[must_use]
501    pub fn right<T: Into<ExprNode<'a>>>(self, size: T) -> Self {
502        right(self, size)
503    }
504
505    #[must_use]
506    pub fn reverse(self) -> ExprNode<'a> {
507        reverse(self)
508    }
509
510    #[must_use]
511    pub fn sign(self) -> ExprNode<'a> {
512        sign(self)
513    }
514
515    #[must_use]
516    pub fn skip<T: Into<ExprNode<'a>>>(self, size: T) -> ExprNode<'a> {
517        skip(self, size)
518    }
519
520    #[must_use]
521    pub fn power<T: Into<ExprNode<'a>>>(self, pwr: T) -> ExprNode<'a> {
522        power(self, pwr)
523    }
524
525    #[must_use]
526    pub fn sqrt(self) -> ExprNode<'a> {
527        sqrt(self)
528    }
529    #[must_use]
530    pub fn gcd<T: Into<ExprNode<'a>>>(self, right: T) -> ExprNode<'a> {
531        gcd(self, right)
532    }
533    #[must_use]
534    pub fn lcm<T: Into<ExprNode<'a>>>(self, right: T) -> ExprNode<'a> {
535        lcm(self, right)
536    }
537    #[must_use]
538    pub fn repeat<T: Into<ExprNode<'a>>>(self, num: T) -> ExprNode<'a> {
539        repeat(self, num)
540    }
541    #[must_use]
542    pub fn replace<T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
543        self,
544        old: T,
545        new: U,
546    ) -> ExprNode<'a> {
547        replace(self, old, new)
548    }
549    #[must_use]
550    pub fn degrees(self) -> ExprNode<'a> {
551        degrees(self)
552    }
553    #[must_use]
554    pub fn radians(self) -> ExprNode<'a> {
555        radians(self)
556    }
557    #[must_use]
558    pub fn lpad<T: Into<ExprNode<'a>>>(self, size: T, fill: Option<ExprNode<'a>>) -> ExprNode<'a> {
559        lpad(self, size, fill)
560    }
561    #[must_use]
562    pub fn rpad<T: Into<ExprNode<'a>>>(self, size: T, fill: Option<ExprNode<'a>>) -> ExprNode<'a> {
563        rpad(self, size, fill)
564    }
565    #[must_use]
566    pub fn take<T: Into<ExprNode<'a>>>(self, size: T) -> ExprNode<'a> {
567        take(self, size)
568    }
569    #[must_use]
570    pub fn exp(self) -> ExprNode<'a> {
571        exp(self)
572    }
573    #[must_use]
574    pub fn substr<T: Into<ExprNode<'a>>>(
575        self,
576        start: T,
577        count: Option<ExprNode<'a>>,
578    ) -> ExprNode<'a> {
579        substr(self, start, count)
580    }
581    #[must_use]
582    pub fn rtrim(self, chars: Option<ExprNode<'a>>) -> ExprNode<'a> {
583        rtrim(self, chars)
584    }
585    #[must_use]
586    pub fn ltrim(self, chars: Option<ExprNode<'a>>) -> ExprNode<'a> {
587        ltrim(self, chars)
588    }
589    #[must_use]
590    pub fn format<T: Into<ExprNode<'a>>>(self, fmt: T) -> ExprNode<'a> {
591        format(self, fmt)
592    }
593    #[must_use]
594    pub fn to_date<T: Into<ExprNode<'a>>>(self, format: T) -> ExprNode<'a> {
595        to_date(self, format)
596    }
597    #[must_use]
598    pub fn to_timestamp<T: Into<ExprNode<'a>>>(self, format: T) -> ExprNode<'a> {
599        to_timestamp(self, format)
600    }
601    #[must_use]
602    pub fn to_time<T: Into<ExprNode<'a>>>(self, format: T) -> ExprNode<'a> {
603        to_time(self, format)
604    }
605    #[must_use]
606    pub fn position<T: Into<ExprNode<'a>>>(self, format: T) -> ExprNode<'a> {
607        position(self, format)
608    }
609    #[must_use]
610    pub fn find_idx<T: Into<ExprNode<'a>>>(
611        self,
612        sub: T,
613        start: Option<ExprNode<'a>>,
614    ) -> ExprNode<'a> {
615        find_idx(self, sub, start)
616    }
617    #[must_use]
618    pub fn cast<T: Into<DataTypeNode>>(self, data_type: T) -> ExprNode<'a> {
619        cast(self, data_type)
620    }
621    #[must_use]
622    pub fn extract(self, field: DateTimeField) -> ExprNode<'a> {
623        extract(field, self)
624    }
625    #[must_use]
626    pub fn is_empty(self) -> ExprNode<'a> {
627        is_empty(self)
628    }
629    #[must_use]
630    pub fn last_day(self) -> ExprNode<'a> {
631        last_day(self)
632    }
633    #[must_use]
634    pub fn entries(self) -> ExprNode<'a> {
635        entries(self)
636    }
637    #[must_use]
638    pub fn keys(self) -> ExprNode<'a> {
639        keys(self)
640    }
641    #[must_use]
642    pub fn values(self) -> ExprNode<'a> {
643        values(self)
644    }
645}
646
647pub fn abs<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
648    ExprNode::Function(Box::new(FunctionNode::Abs(expr.into())))
649}
650pub fn upper<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
651    ExprNode::Function(Box::new(FunctionNode::Upper(expr.into())))
652}
653pub fn lower<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
654    ExprNode::Function(Box::new(FunctionNode::Lower(expr.into())))
655}
656pub fn initcap<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
657    ExprNode::Function(Box::new(FunctionNode::Initcap(expr.into())))
658}
659pub fn ifnull<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(expr: T, then: U) -> ExprNode<'a> {
660    ExprNode::Function(Box::new(FunctionNode::IfNull {
661        expr: expr.into(),
662        then: then.into(),
663    }))
664}
665pub fn nullif<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
666    expr1: T,
667    expr2: U,
668) -> ExprNode<'a> {
669    ExprNode::Function(Box::new(FunctionNode::NullIf {
670        expr1: expr1.into(),
671        expr2: expr2.into(),
672    }))
673}
674pub fn ceil<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
675    ExprNode::Function(Box::new(FunctionNode::Ceil(expr.into())))
676}
677pub fn rand(expr: Option<ExprNode>) -> ExprNode {
678    ExprNode::Function(Box::new(FunctionNode::Rand(expr)))
679}
680pub fn round<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
681    ExprNode::Function(Box::new(FunctionNode::Round(expr.into())))
682}
683pub fn trunc<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
684    ExprNode::Function(Box::new(FunctionNode::Trunc(expr.into())))
685}
686pub fn coalesce<'a, T: Into<ExprList<'a>>>(expr: T) -> ExprNode<'a> {
687    ExprNode::Function(Box::new(FunctionNode::Coalesce(expr.into())))
688}
689pub fn concat<'a, T: Into<ExprList<'a>>>(expr: T) -> ExprNode<'a> {
690    ExprNode::Function(Box::new(FunctionNode::Concat(expr.into())))
691}
692
693pub fn concat_ws<'a, T: Into<ExprNode<'a>>, U: Into<ExprList<'a>>>(
694    separator: T,
695    exprs: U,
696) -> ExprNode<'a> {
697    ExprNode::Function(Box::new(FunctionNode::ConcatWs {
698        separator: separator.into(),
699        exprs: exprs.into(),
700    }))
701}
702
703pub fn floor<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
704    ExprNode::Function(Box::new(FunctionNode::Floor(expr.into())))
705}
706pub fn asin<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
707    ExprNode::Function(Box::new(FunctionNode::Asin(expr.into())))
708}
709pub fn acos<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
710    ExprNode::Function(Box::new(FunctionNode::Acos(expr.into())))
711}
712pub fn atan<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
713    ExprNode::Function(Box::new(FunctionNode::Atan(expr.into())))
714}
715pub fn sin<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
716    ExprNode::Function(Box::new(FunctionNode::Sin(expr.into())))
717}
718pub fn cos<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
719    ExprNode::Function(Box::new(FunctionNode::Cos(expr.into())))
720}
721pub fn tan<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
722    ExprNode::Function(Box::new(FunctionNode::Tan(expr.into())))
723}
724pub fn pi<'a>() -> ExprNode<'a> {
725    ExprNode::Function(Box::new(FunctionNode::Pi))
726}
727pub fn generate_uuid<'a>() -> ExprNode<'a> {
728    ExprNode::Function(Box::new(FunctionNode::GenerateUuid))
729}
730pub fn now<'a>() -> ExprNode<'a> {
731    ExprNode::Function(Box::new(FunctionNode::Now))
732}
733pub fn current_date<'a>() -> ExprNode<'a> {
734    ExprNode::Function(Box::new(FunctionNode::CurrentDate))
735}
736pub fn current_time<'a>() -> ExprNode<'a> {
737    ExprNode::Function(Box::new(FunctionNode::CurrentTime))
738}
739pub fn current_timestamp<'a>() -> ExprNode<'a> {
740    ExprNode::Function(Box::new(FunctionNode::CurrentTimestamp))
741}
742pub fn left<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(expr: T, size: U) -> ExprNode<'a> {
743    ExprNode::Function(Box::new(FunctionNode::Left {
744        expr: expr.into(),
745        size: size.into(),
746    }))
747}
748pub fn log<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(antilog: T, base: U) -> ExprNode<'a> {
749    ExprNode::Function(Box::new(FunctionNode::Log {
750        antilog: antilog.into(),
751        base: base.into(),
752    }))
753}
754pub fn log2<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
755    ExprNode::Function(Box::new(FunctionNode::Log2(expr.into())))
756}
757pub fn log10<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
758    ExprNode::Function(Box::new(FunctionNode::Log10(expr.into())))
759}
760pub fn ln<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
761    ExprNode::Function(Box::new(FunctionNode::Ln(expr.into())))
762}
763pub fn right<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(expr: T, size: U) -> ExprNode<'a> {
764    ExprNode::Function(Box::new(FunctionNode::Right {
765        expr: expr.into(),
766        size: size.into(),
767    }))
768}
769
770pub fn reverse<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
771    ExprNode::Function(Box::new(FunctionNode::Reverse(expr.into())))
772}
773
774pub fn sign<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
775    ExprNode::Function(Box::new(FunctionNode::Sign(expr.into())))
776}
777
778pub fn skip<'a, T: Into<ExprNode<'a>>, V: Into<ExprNode<'a>>>(expr: T, size: V) -> ExprNode<'a> {
779    ExprNode::Function(Box::new(FunctionNode::Skip {
780        expr: expr.into(),
781        size: size.into(),
782    }))
783}
784
785pub fn power<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(expr: T, power: U) -> ExprNode<'a> {
786    ExprNode::Function(Box::new(FunctionNode::Power {
787        expr: expr.into(),
788        power: power.into(),
789    }))
790}
791
792pub fn sqrt<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
793    ExprNode::Function(Box::new(FunctionNode::Sqrt(expr.into())))
794}
795
796pub fn gcd<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(left: T, right: U) -> ExprNode<'a> {
797    ExprNode::Function(Box::new(FunctionNode::Gcd {
798        left: left.into(),
799        right: right.into(),
800    }))
801}
802
803pub fn lcm<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(left: T, right: U) -> ExprNode<'a> {
804    ExprNode::Function(Box::new(FunctionNode::Lcm {
805        left: left.into(),
806        right: right.into(),
807    }))
808}
809
810pub fn repeat<'a, T: Into<ExprNode<'a>>, V: Into<ExprNode<'a>>>(expr: T, num: V) -> ExprNode<'a> {
811    ExprNode::Function(Box::new(FunctionNode::Repeat {
812        expr: expr.into(),
813        num: num.into(),
814    }))
815}
816
817pub fn replace<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>, V: Into<ExprNode<'a>>>(
818    expr: T,
819    old: U,
820    new: V,
821) -> ExprNode<'a> {
822    ExprNode::Function(Box::new(FunctionNode::Replace {
823        expr: expr.into(),
824        old: old.into(),
825        new: new.into(),
826    }))
827}
828
829pub fn lpad<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
830    expr: T,
831    size: U,
832    fill: Option<ExprNode<'a>>,
833) -> ExprNode<'a> {
834    ExprNode::Function(Box::new(FunctionNode::Lpad {
835        expr: expr.into(),
836        size: size.into(),
837        fill,
838    }))
839}
840
841pub fn rpad<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
842    expr: T,
843    size: U,
844    fill: Option<ExprNode<'a>>,
845) -> ExprNode<'a> {
846    ExprNode::Function(Box::new(FunctionNode::Rpad {
847        expr: expr.into(),
848        size: size.into(),
849        fill,
850    }))
851}
852
853pub fn degrees<'a, V: Into<ExprNode<'a>>>(expr: V) -> ExprNode<'a> {
854    ExprNode::Function(Box::new(FunctionNode::Degrees(expr.into())))
855}
856
857pub fn radians<'a, V: Into<ExprNode<'a>>>(expr: V) -> ExprNode<'a> {
858    ExprNode::Function(Box::new(FunctionNode::Radians(expr.into())))
859}
860
861pub fn take<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(expr: T, size: U) -> ExprNode<'a> {
862    ExprNode::Function(Box::new(FunctionNode::Take {
863        expr: expr.into(),
864        size: size.into(),
865    }))
866}
867
868pub fn exp<'a, V: Into<ExprNode<'a>>>(expr: V) -> ExprNode<'a> {
869    ExprNode::Function(Box::new(FunctionNode::Exp(expr.into())))
870}
871pub fn substr<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
872    expr: T,
873    start: U,
874    count: Option<ExprNode<'a>>,
875) -> ExprNode<'a> {
876    ExprNode::Function(Box::new(FunctionNode::Substr {
877        expr: expr.into(),
878        start: start.into(),
879        count,
880    }))
881}
882
883pub fn ltrim<'a, T: Into<ExprNode<'a>>>(expr: T, chars: Option<ExprNode<'a>>) -> ExprNode<'a> {
884    ExprNode::Function(Box::new(FunctionNode::Ltrim {
885        expr: expr.into(),
886        chars,
887    }))
888}
889
890pub fn rtrim<'a, T: Into<ExprNode<'a>>>(expr: T, chars: Option<ExprNode<'a>>) -> ExprNode<'a> {
891    ExprNode::Function(Box::new(FunctionNode::Rtrim {
892        expr: expr.into(),
893        chars,
894    }))
895}
896
897pub fn divide<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
898    dividend: T,
899    divisor: U,
900) -> ExprNode<'a> {
901    ExprNode::Function(Box::new(FunctionNode::Div {
902        dividend: dividend.into(),
903        divisor: divisor.into(),
904    }))
905}
906
907pub fn modulo<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
908    dividend: T,
909    divisor: U,
910) -> ExprNode<'a> {
911    ExprNode::Function(Box::new(FunctionNode::Mod {
912        dividend: dividend.into(),
913        divisor: divisor.into(),
914    }))
915}
916
917pub fn format<'a, D: Into<ExprNode<'a>>, T: Into<ExprNode<'a>>>(
918    expr: D,
919    format: T,
920) -> ExprNode<'a> {
921    ExprNode::Function(Box::new(FunctionNode::Format {
922        expr: expr.into(),
923        format: format.into(),
924    }))
925}
926
927pub fn to_date<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
928    expr: T,
929    format: U,
930) -> ExprNode<'a> {
931    ExprNode::Function(Box::new(FunctionNode::ToDate {
932        expr: expr.into(),
933        format: format.into(),
934    }))
935}
936
937pub fn to_timestamp<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
938    expr: T,
939    format: U,
940) -> ExprNode<'a> {
941    ExprNode::Function(Box::new(FunctionNode::ToTimestamp {
942        expr: expr.into(),
943        format: format.into(),
944    }))
945}
946
947pub fn to_time<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
948    expr: T,
949    format: U,
950) -> ExprNode<'a> {
951    ExprNode::Function(Box::new(FunctionNode::ToTime {
952        expr: expr.into(),
953        format: format.into(),
954    }))
955}
956
957pub fn position<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
958    from_expr: T,
959    sub_expr: U,
960) -> ExprNode<'a> {
961    ExprNode::Function(Box::new(FunctionNode::Position {
962        from_expr: from_expr.into(),
963        sub_expr: sub_expr.into(),
964    }))
965}
966
967pub fn find_idx<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
968    from_expr: T,
969    sub_expr: U,
970    start: Option<ExprNode<'a>>,
971) -> ExprNode<'a> {
972    ExprNode::Function(Box::new(FunctionNode::FindIdx {
973        from_expr: from_expr.into(),
974        sub_expr: sub_expr.into(),
975        start,
976    }))
977}
978
979pub fn cast<'a, T: Into<ExprNode<'a>>, U: Into<DataTypeNode>>(
980    expr: T,
981    data_type: U,
982) -> ExprNode<'a> {
983    ExprNode::Function(Box::new(FunctionNode::Cast {
984        expr: expr.into(),
985        data_type: data_type.into(),
986    }))
987}
988
989pub fn extract<'a, T: Into<ExprNode<'a>>>(field: DateTimeField, expr: T) -> ExprNode<'a> {
990    ExprNode::Function(Box::new(FunctionNode::Extract {
991        field,
992        expr: expr.into(),
993    }))
994}
995
996pub fn ascii<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
997    ExprNode::Function(Box::new(FunctionNode::Ascii(expr.into())))
998}
999
1000pub fn chr<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1001    ExprNode::Function(Box::new(FunctionNode::Chr(expr.into())))
1002}
1003
1004pub fn md5<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1005    ExprNode::Function(Box::new(FunctionNode::Md5(expr.into())))
1006}
1007
1008pub fn hex<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1009    ExprNode::Function(Box::new(FunctionNode::Hex(expr.into())))
1010}
1011
1012pub fn point<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(x: T, y: U) -> ExprNode<'a> {
1013    ExprNode::Function(Box::new(FunctionNode::Point {
1014        x: x.into(),
1015        y: y.into(),
1016    }))
1017}
1018
1019pub fn get_x<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1020    ExprNode::Function(Box::new(FunctionNode::GetX(expr.into())))
1021}
1022
1023pub fn get_y<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1024    ExprNode::Function(Box::new(FunctionNode::GetY(expr.into())))
1025}
1026
1027pub fn greatest<'a, T: Into<ExprList<'a>>>(exprs: T) -> ExprNode<'a> {
1028    ExprNode::Function(Box::new(FunctionNode::Greatest(exprs.into())))
1029}
1030
1031pub fn calc_distance<'a, T: Into<ExprNode<'a>>, U: Into<ExprNode<'a>>>(
1032    geometry1: T,
1033    geometry2: U,
1034) -> ExprNode<'a> {
1035    ExprNode::Function(Box::new(FunctionNode::CalcDistance {
1036        geometry1: geometry1.into(),
1037        geometry2: geometry2.into(),
1038    }))
1039}
1040
1041pub fn length<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1042    ExprNode::Function(Box::new(FunctionNode::Length(expr.into())))
1043}
1044
1045pub fn is_empty<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1046    ExprNode::Function(Box::new(FunctionNode::IsEmpty(expr.into())))
1047}
1048
1049pub fn last_day<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1050    ExprNode::Function(Box::new(FunctionNode::LastDay(expr.into())))
1051}
1052
1053pub fn entries<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1054    ExprNode::Function(Box::new(FunctionNode::Entries(expr.into())))
1055}
1056
1057pub fn keys<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1058    ExprNode::Function(Box::new(FunctionNode::Keys(expr.into())))
1059}
1060
1061pub fn values<'a, T: Into<ExprNode<'a>>>(expr: T) -> ExprNode<'a> {
1062    ExprNode::Function(Box::new(FunctionNode::Values(expr.into())))
1063}
1064
1065#[cfg(test)]
1066mod tests {
1067    use crate::{
1068        ast::DateTimeField,
1069        ast_builder::function as f,
1070        ast_builder::{col, date, expr, null, num, test_expr, text, time, timestamp},
1071        prelude::DataType,
1072    };
1073
1074    #[test]
1075    fn function_abs() {
1076        let actual = f::abs(col("num"));
1077        let expected = "ABS(num)";
1078        test_expr(actual, expected);
1079
1080        let actual = expr("base - 10").abs();
1081        let expected = "ABS(base - 10)";
1082        test_expr(actual, expected);
1083    }
1084
1085    #[test]
1086    fn function_upper() {
1087        let actual = f::upper(text("ABC"));
1088        let expected = "UPPER('ABC')";
1089        test_expr(actual, expected);
1090
1091        let actual = expr("HoHo").upper();
1092        let expected = "UPPER(HoHo)";
1093        test_expr(actual, expected);
1094    }
1095    #[test]
1096    fn function_ifnull() {
1097        let actual = f::ifnull(text("HELLO"), text("WORLD"));
1098        let expected = "IFNULL('HELLO', 'WORLD')";
1099        test_expr(actual, expected);
1100
1101        let actual = col("updated_at").ifnull(col("created_at"));
1102        let expected = "IFNULL(updated_at, created_at)";
1103        test_expr(actual, expected);
1104    }
1105
1106    #[test]
1107    fn function_nullif() {
1108        let actual = f::nullif(text("hello"), text("world"));
1109        let expected = "NULLIF('hello', 'world')";
1110        test_expr(actual, expected);
1111
1112        let actual = col("updated_at").nullif(col("created_at"));
1113        let expected = "NULLIF(updated_at, created_at)";
1114        test_expr(actual, expected);
1115    }
1116
1117    #[test]
1118    fn function_ceil() {
1119        let actual = f::ceil(col("num"));
1120        let expected = "CEIL(num)";
1121        test_expr(actual, expected);
1122
1123        let actual = expr("base - 10").ceil();
1124        let expected = "CEIL(base - 10)";
1125        test_expr(actual, expected);
1126    }
1127
1128    #[test]
1129    fn function_rand() {
1130        let actual = f::rand(None);
1131        let expected = "RAND()";
1132        test_expr(actual, expected);
1133
1134        let actual = f::rand(Some(col("num")));
1135        let expected = "RAND(num)";
1136        test_expr(actual, expected);
1137
1138        let actual = expr("base - 10").rand();
1139        let expected = "RAND(base - 10)";
1140        test_expr(actual, expected);
1141    }
1142
1143    #[test]
1144    fn function_round() {
1145        let actual = f::round(col("num"));
1146        let expected = "ROUND(num)";
1147        test_expr(actual, expected);
1148
1149        let actual = expr("base - 10").round();
1150        let expected = "ROUND(base - 10)";
1151        test_expr(actual, expected);
1152    }
1153
1154    #[test]
1155    fn function_trunc() {
1156        let actual = f::trunc(col("num"));
1157        let expected = "trunc(num)";
1158        test_expr(actual, expected);
1159
1160        let actual = expr("base - 10").trunc();
1161        let expected = "TRUNC(base - 10)";
1162        test_expr(actual, expected);
1163    }
1164
1165    #[test]
1166    fn function_floor() {
1167        let actual = f::floor(col("num"));
1168        let expected = "FLOOR(num)";
1169        test_expr(actual, expected);
1170
1171        let actual = expr("base - 10").floor();
1172        let expected = "FLOOR(base - 10)";
1173        test_expr(actual, expected);
1174    }
1175
1176    #[test]
1177    fn function_trigonometrics() {
1178        // asin
1179        let actual = f::asin(col("num"));
1180        let expected = "ASIN(num)";
1181        test_expr(actual, expected);
1182
1183        let actual = col("num").asin();
1184        let expected = "ASIN(num)";
1185        test_expr(actual, expected);
1186
1187        // acos
1188        let actual = f::acos(col("num"));
1189        let expected = "ACOS(num)";
1190        test_expr(actual, expected);
1191
1192        let actual = col("num").acos();
1193        let expected = "ACOS(num)";
1194        test_expr(actual, expected);
1195
1196        // atan
1197        let actual = f::atan(col("num"));
1198        let expected = "ATAN(num)";
1199        test_expr(actual, expected);
1200
1201        let actual = col("num").atan();
1202        let expected = "ATAN(num)";
1203        test_expr(actual, expected);
1204
1205        // sin
1206        let actual = f::sin(col("num"));
1207        let expected = "SIN(num)";
1208        test_expr(actual, expected);
1209
1210        let actual = col("num").sin();
1211        let expected = "SIN(num)";
1212        test_expr(actual, expected);
1213
1214        // cos
1215        let actual = f::cos(col("num"));
1216        let expected = "COS(num)";
1217        test_expr(actual, expected);
1218
1219        let actual = col("num").cos();
1220        let expected = "COS(num)";
1221        test_expr(actual, expected);
1222
1223        // tan
1224        let actual = f::tan(col("num"));
1225        let expected = "TAN(num)";
1226        test_expr(actual, expected);
1227
1228        let actual = col("num").tan();
1229        let expected = "TAN(num)";
1230        test_expr(actual, expected);
1231
1232        // pi
1233        let actual = f::pi();
1234        let expected = "PI()";
1235        test_expr(actual, expected);
1236    }
1237
1238    #[test]
1239    fn function_now() {
1240        let actual = f::now();
1241        let expected = "NOW()";
1242        test_expr(actual, expected);
1243    }
1244
1245    #[test]
1246    fn function_current_date() {
1247        let actual = f::current_date();
1248        let expected = "CURRENT_DATE()";
1249        test_expr(actual, expected);
1250    }
1251
1252    #[test]
1253    fn function_current_time() {
1254        let actual = f::current_time();
1255        let expected = "CURRENT_TIME()";
1256        test_expr(actual, expected);
1257    }
1258
1259    #[test]
1260    fn function_current_timestamp() {
1261        let actual = f::current_timestamp();
1262        let expected = "CURRENT_TIMESTAMP()";
1263        test_expr(actual, expected);
1264    }
1265
1266    #[test]
1267    fn function_generate_uuid() {
1268        let actual = f::generate_uuid();
1269        let expected = "GENERATE_UUID()";
1270        test_expr(actual, expected);
1271    }
1272
1273    #[test]
1274    fn function_left() {
1275        let actual = f::left(text("GlueSQL"), num(2));
1276        let expected = "LEFT('GlueSQL', 2)";
1277        test_expr(actual, expected);
1278
1279        let actual = expr("GlueSQL").left(num(2));
1280        let expected = "LEFT(GlueSQL, 2)";
1281        test_expr(actual, expected);
1282    }
1283
1284    #[test]
1285    fn function_log() {
1286        let actual = f::log(num(64), num(8));
1287        let expected = "log(64,8)";
1288        test_expr(actual, expected);
1289
1290        let actual = num(64).log(num(8));
1291        let expected = "LOG(64,8)";
1292        test_expr(actual, expected);
1293    }
1294
1295    #[test]
1296    fn function_log2() {
1297        let actual = f::log2(col("num"));
1298        let expected = "LOG2(num)";
1299        test_expr(actual, expected);
1300
1301        let actual = col("num").log2();
1302        let expected = "LOG2(num)";
1303        test_expr(actual, expected);
1304    }
1305
1306    #[test]
1307    fn function_log10() {
1308        let actual = f::log10(col("num"));
1309        let expected = "LOG10(num)";
1310        test_expr(actual, expected);
1311
1312        let actual = col("num").log10();
1313        let expected = "LOG10(num)";
1314        test_expr(actual, expected);
1315    }
1316
1317    #[test]
1318    fn function_ln() {
1319        let actual = f::ln(num(2));
1320        let expected = "LN(2)";
1321        test_expr(actual, expected);
1322
1323        let actual = num(2).ln();
1324        let expected = "LN(2)";
1325        test_expr(actual, expected);
1326    }
1327
1328    #[test]
1329    fn function_right() {
1330        let actual = f::right(text("GlueSQL"), num(2));
1331        let expected = "RIGHT('GlueSQL', 2)";
1332        test_expr(actual, expected);
1333
1334        let actual = expr("GlueSQL").right(num(2));
1335        let expected = "RIGHT(GlueSQL, 2)";
1336        test_expr(actual, expected);
1337    }
1338
1339    #[test]
1340    fn function_reverse() {
1341        let actual = f::reverse(text("GlueSQL"));
1342        let expected = "REVERSE('GlueSQL')";
1343        test_expr(actual, expected);
1344
1345        let actual = expr("GlueSQL").reverse();
1346        let expected = "REVERSE(GlueSQL)";
1347        test_expr(actual, expected);
1348    }
1349
1350    #[test]
1351    fn function_sign() {
1352        let actual = f::sign(col("id"));
1353        let expected = "SIGN(id)";
1354        test_expr(actual, expected);
1355
1356        let actual = expr("id").sign();
1357        let expected = "SIGN(id)";
1358        test_expr(actual, expected);
1359    }
1360
1361    #[test]
1362    fn function_skip() {
1363        let actual = f::skip(col("list"), num(2));
1364        let expected = "SKIP(list,2)";
1365        test_expr(actual, expected);
1366
1367        let actual = expr("list").skip(num(2));
1368        let expected = "SKIP(list,2)";
1369        test_expr(actual, expected);
1370    }
1371
1372    #[test]
1373    fn function_power() {
1374        let actual = f::power(num(2), num(4));
1375        let expected = "POWER(2,4)";
1376        test_expr(actual, expected);
1377
1378        let actual = num(2).power(num(4));
1379        let expected = "POWER(2,4)";
1380        test_expr(actual, expected);
1381    }
1382
1383    #[test]
1384    fn function_sqrt() {
1385        let actual = f::sqrt(num(9));
1386        let expected = "SQRT(9)";
1387        test_expr(actual, expected);
1388
1389        let actual = num(9).sqrt();
1390        let expected = "SQRT(9)";
1391        test_expr(actual, expected);
1392    }
1393
1394    #[test]
1395    fn function_gcd() {
1396        let actual = f::gcd(num(64), num(8));
1397        let expected = "gcd(64,8)";
1398        test_expr(actual, expected);
1399
1400        let actual = num(64).gcd(num(8));
1401        let expected = "GCD(64,8)";
1402        test_expr(actual, expected);
1403    }
1404
1405    #[test]
1406    fn function_lcm() {
1407        let actual = f::lcm(num(64), num(8));
1408        let expected = "lcm(64,8)";
1409        test_expr(actual, expected);
1410
1411        let actual = num(64).lcm(num(8));
1412        let expected = "LCM(64,8)";
1413        test_expr(actual, expected);
1414    }
1415
1416    #[test]
1417    fn function_repeat() {
1418        let actual = f::repeat(text("GlueSQL"), num(2));
1419        let expected = "REPEAT('GlueSQL', 2)";
1420        test_expr(actual, expected);
1421
1422        let actual = text("GlueSQL").repeat(num(2));
1423        let expected = "REPEAT('GlueSQL', 2)";
1424        test_expr(actual, expected);
1425    }
1426
1427    #[test]
1428    fn function_degrees() {
1429        let actual = f::degrees(num(1));
1430        let expected = "DEGREES(1)";
1431        test_expr(actual, expected);
1432
1433        let actual = num(1).degrees();
1434        let expected = "DEGREES(1)";
1435        test_expr(actual, expected);
1436    }
1437
1438    #[test]
1439    fn function_radians() {
1440        let actual = f::radians(num(1));
1441        let expected = "RADIANS(1)";
1442        test_expr(actual, expected);
1443
1444        let actual = num(1).radians();
1445        let expected = "RADIANS(1)";
1446        test_expr(actual, expected);
1447    }
1448
1449    #[test]
1450    fn function_coalesce() {
1451        let actual = f::coalesce(vec![null(), text("Glue")]);
1452        let expected = "COALESCE(NULL, 'Glue')";
1453        test_expr(actual, expected);
1454    }
1455
1456    #[test]
1457    fn function_concat() {
1458        let actual = f::concat(vec![text("Glue"), text("SQL"), text("Go")]);
1459        let expected = "CONCAT('Glue','SQL','Go')";
1460        test_expr(actual, expected);
1461
1462        let actual = f::concat(vec!["Glue", "SQL", "Go"]);
1463        let expected = "CONCAT(Glue, SQL, Go)";
1464        test_expr(actual, expected);
1465    }
1466
1467    #[test]
1468    fn function_concat_ws() {
1469        let actual = f::concat_ws(text(","), vec![text("Glue"), text("SQL"), text("Go")]);
1470        let expected = "CONCAT_WS(',', 'Glue', 'SQL', 'Go')";
1471        test_expr(actual, expected);
1472
1473        let actual = f::concat_ws(text(","), vec!["Glue", "SQL", "Go"]);
1474        let expected = "CONCAT_WS(',', Glue, SQL, Go)";
1475        test_expr(actual, expected);
1476    }
1477
1478    #[test]
1479    fn function_lpad() {
1480        let actual = f::lpad(text("GlueSQL"), num(10), Some(text("Go")));
1481        let expected = "LPAD('GlueSQL', 10, 'Go')";
1482        test_expr(actual, expected);
1483
1484        let actual = f::lpad(text("GlueSQL"), num(10), None);
1485        let expected = "LPAD('GlueSQL', 10)";
1486        test_expr(actual, expected);
1487
1488        let actual = text("GlueSQL").lpad(num(10), Some(text("Go")));
1489        let expected = "LPAD('GlueSQL', 10, 'Go')";
1490        test_expr(actual, expected);
1491
1492        let actual = text("GlueSQL").lpad(num(10), None);
1493        let expected = "LPAD('GlueSQL', 10)";
1494        test_expr(actual, expected);
1495    }
1496
1497    #[test]
1498    fn function_rpad() {
1499        let actual = f::rpad(text("GlueSQL"), num(10), Some(text("Go")));
1500        let expected = "RPAD('GlueSQL', 10, 'Go')";
1501        test_expr(actual, expected);
1502
1503        let actual = f::rpad(text("GlueSQL"), num(10), None);
1504        let expected = "RPAD('GlueSQL', 10)";
1505        test_expr(actual, expected);
1506
1507        let actual = text("GlueSQL").rpad(num(10), Some(text("Go")));
1508        let expected = "RPAD('GlueSQL', 10, 'Go')";
1509        test_expr(actual, expected);
1510
1511        let actual = text("GlueSQL").rpad(num(10), None);
1512        let expected = "RPAD('GlueSQL', 10)";
1513        test_expr(actual, expected);
1514    }
1515
1516    #[test]
1517    fn function_take() {
1518        let actual = f::take(col("list"), num(3));
1519        let expected = "TAKE(list,3)";
1520        test_expr(actual, expected);
1521
1522        let actual = expr("list").take(num(3));
1523        let expected = "TAKE(list,3)";
1524        test_expr(actual, expected);
1525    }
1526
1527    #[test]
1528    fn function_exp() {
1529        let actual = f::exp(num(2));
1530        let expected = "EXP(2)";
1531        test_expr(actual, expected);
1532
1533        let actual = num(2).exp();
1534        let expected = "EXP(2)";
1535        test_expr(actual, expected);
1536    }
1537
1538    #[test]
1539    fn function_substr() {
1540        let actual = f::substr(text("GlueSQL"), num(2), Some(num(4)));
1541        let expected = "SUBSTR('GlueSQL', 2, 4)";
1542        test_expr(actual, expected);
1543
1544        let actual = f::substr(text("GlueSQL"), num(2), None);
1545        let expected = "SUBSTR('GlueSQL', 2)";
1546        test_expr(actual, expected);
1547
1548        let actual = text("GlueSQL").substr(num(2), Some(num(4)));
1549        let expected = "SUBSTR('GlueSQL', 2, 4)";
1550        test_expr(actual, expected);
1551
1552        let actual = text("GlueSQL").substr(num(2), None);
1553        let expected = "SUBSTR('GlueSQL', 2)";
1554        test_expr(actual, expected);
1555
1556        let actual = text("GlueSQL").substr(num(2), None);
1557        let expected = "SUBSTR('GlueSQL', 2)";
1558        test_expr(actual, expected);
1559
1560        let actual = f::substr(text("GlueSQL      ").rtrim(None), num(2), None);
1561        let expected = "SUBSTR(RTRIM('GlueSQL      '), 2)";
1562        test_expr(actual, expected);
1563
1564        let actual = text("GlueSQL      ").rtrim(None).substr(num(2), None);
1565        let expected = "SUBSTR(RTRIM('GlueSQL      '), 2)";
1566        test_expr(actual, expected);
1567
1568        let actual = f::substr(text("      GlueSQL").ltrim(None), num(2), None);
1569        let expected = "SUBSTR(LTRIM('      GlueSQL'), 2)";
1570        test_expr(actual, expected);
1571
1572        let actual = text("      GlueSQL").ltrim(None).substr(num(2), None);
1573        let expected = "SUBSTR(LTRIM('      GlueSQL'), 2)";
1574        test_expr(actual, expected);
1575    }
1576
1577    #[test]
1578    fn function_rtrim() {
1579        let actual = f::rtrim(text("GlueSQL      "), None);
1580        let expected = "RTRIM('GlueSQL      ')";
1581        test_expr(actual, expected);
1582
1583        let actual = text("GlueSQL      ").rtrim(None);
1584        let expected = "RTRIM('GlueSQL      ')";
1585        test_expr(actual, expected);
1586
1587        let actual = f::rtrim(text("GlueSQLABC"), Some(text("ABC")));
1588        let expected = "RTRIM('GlueSQLABC','ABC')";
1589        test_expr(actual, expected);
1590
1591        let actual = text("GlueSQLABC").rtrim(Some(text("ABC")));
1592        let expected = "RTRIM('GlueSQLABC','ABC')";
1593        test_expr(actual, expected);
1594
1595        let actual = text("chicken").ltrim(None).rtrim(Some(text("en")));
1596        let expected = "RTRIM(LTRIM('chicken'),'en')";
1597        test_expr(actual, expected);
1598
1599        let actual = f::rtrim(text("chicken").ltrim(Some(text("chick"))), None);
1600        let expected = "RTRIM(LTRIM('chicken','chick'))";
1601        test_expr(actual, expected);
1602    }
1603
1604    #[test]
1605    fn function_ltrim() {
1606        let actual = f::ltrim(text("      GlueSQL"), None);
1607        let expected = "LTRIM('      GlueSQL')";
1608        test_expr(actual, expected);
1609
1610        let actual = text("      GlueSQL").ltrim(None);
1611        let expected = "LTRIM('      GlueSQL')";
1612        test_expr(actual, expected);
1613
1614        let actual = f::ltrim(text("ABCGlueSQL"), Some(text("ABC")));
1615        let expected = "LTRIM('ABCGlueSQL','ABC')";
1616        test_expr(actual, expected);
1617
1618        let actual = text("ABCGlueSQL").ltrim(Some(text("ABC")));
1619        let expected = "LTRIM('ABCGlueSQL','ABC')";
1620        test_expr(actual, expected);
1621
1622        let actual = text("chicken").rtrim(Some(text("en"))).ltrim(None);
1623        let expected = "LTRIM(RTRIM('chicken','en'))";
1624        test_expr(actual, expected);
1625
1626        let actual = text("chicken").rtrim(None).ltrim(Some(text("chick")));
1627        let expected = "LTRIM(RTRIM('chicken'),'chick')";
1628        test_expr(actual, expected);
1629    }
1630
1631    #[test]
1632    fn function_mod() {
1633        let actual = f::modulo(num(64), num(8));
1634        let expected = "mod(64,8)";
1635        test_expr(actual, expected);
1636    }
1637
1638    #[test]
1639    fn function_div() {
1640        let actual = f::divide(num(64), num(8));
1641        let expected = "div(64,8)";
1642        test_expr(actual, expected);
1643    }
1644
1645    #[test]
1646    fn function_format() {
1647        let actual = f::format(date("2017-06-15"), text("%Y-%m"));
1648        let expected = "FORMAT(DATE'2017-06-15','%Y-%m')";
1649        test_expr(actual, expected);
1650
1651        let actual = date("2017-06-15").format(text("%Y-%m"));
1652        let expected = "FORMAT(DATE '2017-06-15','%Y-%m')";
1653        test_expr(actual, expected);
1654
1655        let actual = f::format(timestamp("2015-09-05 23:56:04"), text("%Y-%m-%d %H:%M:%S"));
1656        let expected = "FORMAT(TIMESTAMP '2015-09-05 23:56:04', '%Y-%m-%d %H:%M:%S')";
1657        test_expr(actual, expected);
1658
1659        let actual = timestamp("2015-09-05 23:56:04").format(text("%Y-%m-%d %H:%M:%S"));
1660        let expected = "FORMAT(TIMESTAMP '2015-09-05 23:56:04', '%Y-%m-%d %H:%M:%S')";
1661        test_expr(actual, expected);
1662
1663        let actual = f::format(time("23:56:04"), text("%H:%M:%S"));
1664        let expected = "FORMAT(TIME '23:56:04', '%H:%M:%S')";
1665        test_expr(actual, expected);
1666
1667        let actual = time("23:56:04").format(text("%H:%M:%S"));
1668        let expected = "FORMAT(TIME '23:56:04', '%H:%M:%S')";
1669        test_expr(actual, expected);
1670    }
1671
1672    #[test]
1673    fn function_to_date() {
1674        let actual = f::to_date(text("2017-06-15"), text("%Y-%m-%d"));
1675        let expected = "TO_DATE('2017-06-15','%Y-%m-%d')";
1676        test_expr(actual, expected);
1677
1678        let actual = text("2017-06-15").to_date(text("%Y-%m-%d"));
1679        let expected = "TO_DATE('2017-06-15','%Y-%m-%d')";
1680        test_expr(actual, expected);
1681    }
1682
1683    #[test]
1684    fn function_to_timestamp() {
1685        let actual = f::to_timestamp(text("2015-09-05 23:56:04"), text("%Y-%m-%d %H:%M:%S"));
1686        let expected = "TO_TIMESTAMP('2015-09-05 23:56:04','%Y-%m-%d %H:%M:%S')";
1687        test_expr(actual, expected);
1688
1689        let actual = text("2015-09-05 23:56:04").to_timestamp(text("%Y-%m-%d %H:%M:%S"));
1690        let expected = "TO_TIMESTAMP('2015-09-05 23:56:04','%Y-%m-%d %H:%M:%S')";
1691        test_expr(actual, expected);
1692    }
1693
1694    #[test]
1695    fn function_to_time() {
1696        let actual = f::to_time(text("23:56:04"), text("%H:%M:%S"));
1697        let expected = "TO_TIME('23:56:04','%H:%M:%S')";
1698        test_expr(actual, expected);
1699
1700        let actual = text("23:56:04").to_time(text("%H:%M:%S"));
1701        let expected = "TO_TIME('23:56:04','%H:%M:%S')";
1702        test_expr(actual, expected);
1703    }
1704
1705    #[test]
1706    fn function_lower() {
1707        // Lower
1708        let actual = f::lower(text("ABC"));
1709        let expected = "LOWER('ABC')";
1710        test_expr(actual, expected);
1711
1712        let actual = expr("HoHo").lower();
1713        let expected = "LOWER(HoHo)";
1714        test_expr(actual, expected);
1715    }
1716
1717    #[test]
1718    fn function_initcap() {
1719        // Initcap
1720        let actual = f::initcap(text("ABC"));
1721        let expected = "INITCAP('ABC')";
1722        test_expr(actual, expected);
1723
1724        let actual = expr("HoHo").initcap();
1725        let expected = "INITCAP(HoHo)";
1726        test_expr(actual, expected);
1727    }
1728
1729    #[test]
1730    fn function_position() {
1731        let actual = f::position(expr("cake"), text("ke"));
1732        let expected = "POSITION('ke' IN cake)";
1733        test_expr(actual, expected);
1734
1735        let actual = text("rice").position(text("cake"));
1736        let expected = "POSITION('cake' IN 'rice')";
1737        test_expr(actual, expected);
1738    }
1739
1740    #[test]
1741    fn function_find_idx() {
1742        let actual = f::find_idx(expr("oatmeal"), text("meal"), Some(num(2)));
1743        let expected = "FIND_IDX(oatmeal, 'meal', 2)";
1744        test_expr(actual, expected);
1745
1746        let actual = f::find_idx(expr("strawberry"), text("berry"), None);
1747        let expected = "FIND_IDX(strawberry, 'berry')";
1748        test_expr(actual, expected);
1749
1750        let actual = expr("blackberry").find_idx(text("black"), Some(num(1)));
1751        let expected = "FIND_IDX(blackberry, 'black', 1)";
1752        test_expr(actual, expected);
1753
1754        let actual = text("blue cheese").find_idx(text("blue"), None);
1755        let expected = "FIND_IDX('blue cheese', 'blue')";
1756        test_expr(actual, expected);
1757    }
1758
1759    #[test]
1760    fn function_cast() {
1761        let actual = col("date").cast(DataType::Int);
1762        let expected = "CAST(date AS INTEGER)";
1763        test_expr(actual, expected);
1764
1765        let actual = f::cast(expr("date"), "INTEGER");
1766        let expected = "CAST(date AS INTEGER)";
1767        test_expr(actual, expected);
1768    }
1769
1770    #[test]
1771    fn function_extract() {
1772        let actual = col("date").extract(DateTimeField::Year);
1773        let expected = "EXTRACT(YEAR FROM date)";
1774        test_expr(actual, expected);
1775
1776        let actual = f::extract(DateTimeField::Year, expr("date"));
1777        let expected = "EXTRACT(YEAR FROM date)";
1778        test_expr(actual, expected);
1779    }
1780
1781    #[test]
1782    fn function_ascii() {
1783        let actual = f::ascii(text("A"));
1784        let expected = "ASCII('A')";
1785        test_expr(actual, expected);
1786    }
1787
1788    #[test]
1789    fn function_chr() {
1790        let actual = f::chr(num(65));
1791        let expected = "CHR(65)";
1792        test_expr(actual, expected);
1793    }
1794
1795    #[test]
1796    fn function_md5() {
1797        let actual = f::md5(text("abc"));
1798        let expected = "MD5('abc')";
1799        test_expr(actual, expected);
1800    }
1801
1802    #[test]
1803    fn function_hex() {
1804        let actual = f::hex(num(10));
1805        let expected = "HEX(10)";
1806        test_expr(actual, expected);
1807
1808        let actual = f::hex(text("10"));
1809        let expected = "HEX('10')";
1810        test_expr(actual, expected);
1811
1812        let actual = f::hex(text("GlueSQL"));
1813        let expected = "HEX('GlueSQL')";
1814        test_expr(actual, expected);
1815    }
1816
1817    #[test]
1818    fn function_point() {
1819        let actual = f::point(num(1), num(2));
1820        let expected = "POINT(1, 2)";
1821        test_expr(actual, expected);
1822    }
1823
1824    #[test]
1825    fn function_get_x() {
1826        let actual = f::get_x(f::point(num(1), num(2)));
1827        let expected = "GET_X(POINT(1, 2))";
1828        test_expr(actual, expected);
1829    }
1830
1831    #[test]
1832    fn function_get_y() {
1833        let actual = f::get_y(f::point(num(1), num(2)));
1834        let expected = "GET_Y(POINT(1, 2))";
1835        test_expr(actual, expected);
1836    }
1837
1838    #[test]
1839    fn function_greatest() {
1840        let actual = f::greatest(vec![num(1), num(2), num(3)]);
1841        let expected = "GREATEST(1, 2, 3)";
1842        test_expr(actual, expected);
1843
1844        let actual = f::greatest(vec![text("Glue"), text("SQL"), text("Go")]);
1845        let expected = "GREATEST('Glue','SQL','Go')";
1846        test_expr(actual, expected);
1847    }
1848
1849    #[test]
1850    fn function_calc_distance() {
1851        let actual = f::calc_distance(f::point(num(1), num(2)), f::point(num(3), num(4)));
1852        let expected = "CALC_DISTANCE(POINT(1, 2), POINT(3, 4))";
1853        test_expr(actual, expected);
1854    }
1855
1856    #[test]
1857    fn function_replace() {
1858        let actual = f::replace(text("Mticky GlueMQL"), text("M"), text("S"));
1859        let expected = "REPLACE('Mticky GlueMQL','M','S')";
1860        test_expr(actual, expected);
1861
1862        let actual = text("Mticky GlueMQL").replace(text("M"), text("S"));
1863        let expected = "REPLACE('Mticky GlueMQL','M','S')";
1864        test_expr(actual, expected);
1865    }
1866
1867    #[test]
1868    fn function_length() {
1869        let actual = f::length(text("GlueSQL"));
1870        let expected = "LENGTH('GlueSQL')";
1871        test_expr(actual, expected);
1872    }
1873
1874    #[test]
1875    fn function_is_empty() {
1876        let actual = col("list").is_empty();
1877        let expected = "IS_EMPTY(list)";
1878        test_expr(actual, expected);
1879
1880        let actual = f::is_empty(col("list"));
1881        let expected = "IS_EMPTY(list)";
1882        test_expr(actual, expected);
1883    }
1884
1885    #[test]
1886    fn function_last_day_date() {
1887        let actual = f::last_day(date("2023-07-29"));
1888        let expected = "LAST_DAY(DATE'2023-07-29')";
1889        test_expr(actual, expected);
1890
1891        let actual = date("2023-07-29").last_day();
1892        let expected = "LAST_DAY(DATE'2023-07-29')";
1893        test_expr(actual, expected);
1894    }
1895
1896    #[test]
1897    fn function_last_day_timestamp() {
1898        let actual = f::last_day(timestamp("2023-07-29 11:00:00"));
1899        let expected = "LAST_DAY(TIMESTAMP '2023-07-29 11:00:00')";
1900        test_expr(actual, expected);
1901
1902        let actual = timestamp("2023-07-29 11:00:00").last_day();
1903        let expected = "LAST_DAY(TIMESTAMP '2023-07-29 11:00:00')";
1904        test_expr(actual, expected);
1905    }
1906
1907    #[test]
1908    fn function_entries() {
1909        let actual = f::entries(col("map"));
1910        let expected = "ENTRIES(map)";
1911        test_expr(actual, expected);
1912
1913        let actual = col("map").entries();
1914        let expected = "ENTRIES(map)";
1915        test_expr(actual, expected);
1916    }
1917
1918    #[test]
1919    fn function_fn_values() {
1920        let actual = col("map").values();
1921        let expected = "VALUES(map)";
1922        test_expr(actual, expected);
1923
1924        let actual = f::values(col("map"));
1925        let expected = "VALUES(map)";
1926        test_expr(actual, expected);
1927    }
1928
1929    #[test]
1930    fn function_keys() {
1931        let actual = f::keys(col("map"));
1932        let expected = "KEYS(map)";
1933        test_expr(actual, expected);
1934
1935        let actual = col("map").keys();
1936        let expected = "KEYS(map)";
1937        test_expr(actual, expected);
1938    }
1939}
gluesql_core/ast_builder/expr/function.rs

gluesql_core/ast_builder/expr/
function.rs
