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