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