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 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 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 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 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 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 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 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 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 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}