qrlew/expr/
sql.rs

1//! Convert Expr into ast::Expr
2use crate::{
3    ast,
4    data_type::DataType,
5    expr::{self, Expr},
6    visitor::Acceptor,
7};
8use std::iter::Iterator;
9
10/// A simple Expr -> ast::Expr conversion Visitor
11pub struct FromExprVisitor;
12
13impl<'a> expr::Visitor<'a, ast::Expr> for FromExprVisitor {
14    fn column(&self, column: &'a expr::Column) -> ast::Expr {
15        if column.len() == 1 {
16            ast::Expr::Identifier(ast::Ident::new(column.head().unwrap()))
17        } else {
18            ast::Expr::CompoundIdentifier(column.iter().map(|id| ast::Ident::new(id)).collect())
19        }
20    }
21
22    fn value(&self, value: &'a expr::Value) -> ast::Expr {
23        match value {
24            crate::data_type::value::Value::Unit(_) => ast::Expr::Value(ast::Value::Null),
25            crate::data_type::value::Value::Boolean(b) => {
26                ast::Expr::Value(ast::Value::Boolean(**b))
27            }
28            crate::data_type::value::Value::Integer(i) => {
29                ast::Expr::Value(ast::Value::Number(format!("{}", **i), false))
30            }
31            crate::data_type::value::Value::Enum(_) => todo!(),
32            crate::data_type::value::Value::Float(f) => {
33                ast::Expr::Value(ast::Value::Number(format!("{}", **f), false))
34            }
35            crate::data_type::value::Value::Text(t) => {
36                ast::Expr::Value(ast::Value::SingleQuotedString(format!("{}", **t)))
37            }
38            crate::data_type::value::Value::Bytes(_) => todo!(),
39            crate::data_type::value::Value::Struct(_) => todo!(),
40            crate::data_type::value::Value::Union(_) => todo!(),
41            crate::data_type::value::Value::Optional(_) => todo!(),
42            crate::data_type::value::Value::List(l) => ast::Expr::Tuple(
43                l.to_vec()
44                    .iter()
45                    .map(|v| self.value(v))
46                    .collect::<Vec<ast::Expr>>(),
47            ),
48            crate::data_type::value::Value::Set(_) => todo!(),
49            crate::data_type::value::Value::Array(_) => todo!(),
50            crate::data_type::value::Value::Date(_) => todo!(),
51            crate::data_type::value::Value::Time(_) => todo!(),
52            crate::data_type::value::Value::DateTime(_) => todo!(),
53            crate::data_type::value::Value::Duration(_) => todo!(),
54            crate::data_type::value::Value::Id(_) => todo!(),
55            crate::data_type::value::Value::Function(_) => todo!(),
56        }
57    }
58
59    fn function(
60        &self,
61        function: &'a expr::function::Function,
62        arguments: Vec<ast::Expr>,
63    ) -> ast::Expr {
64        match function {
65            expr::function::Function::Opposite => ast::Expr::UnaryOp {
66                op: ast::UnaryOperator::Minus,
67                expr: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
68            },
69            expr::function::Function::Not => ast::Expr::UnaryOp {
70                op: ast::UnaryOperator::Not,
71                expr: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
72            },
73            expr::function::Function::Plus => ast::Expr::BinaryOp {
74                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
75                op: ast::BinaryOperator::Plus,
76                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
77            },
78            expr::function::Function::Minus => ast::Expr::BinaryOp {
79                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
80                op: ast::BinaryOperator::Minus,
81                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
82            },
83            expr::function::Function::Multiply => ast::Expr::BinaryOp {
84                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
85                op: ast::BinaryOperator::Multiply,
86                right: Box::new(ast::Expr::Nested(Box::new(ast::Expr::Nested(Box::new(
87                    arguments[1].clone(),
88                ))))),
89            },
90            expr::function::Function::Divide => ast::Expr::BinaryOp {
91                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
92                op: ast::BinaryOperator::Divide,
93                right: Box::new(ast::Expr::Nested(Box::new(ast::Expr::Nested(Box::new(
94                    arguments[1].clone(),
95                ))))),
96            },
97            expr::function::Function::Modulo => ast::Expr::BinaryOp {
98                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
99                op: ast::BinaryOperator::Modulo,
100                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
101            },
102            expr::function::Function::StringConcat => ast::Expr::BinaryOp {
103                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
104                op: ast::BinaryOperator::StringConcat,
105                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
106            },
107            expr::function::Function::Gt => ast::Expr::BinaryOp {
108                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
109                op: ast::BinaryOperator::Gt,
110                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
111            },
112            expr::function::Function::Lt => ast::Expr::BinaryOp {
113                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
114                op: ast::BinaryOperator::Lt,
115                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
116            },
117            expr::function::Function::GtEq => ast::Expr::BinaryOp {
118                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
119                op: ast::BinaryOperator::GtEq,
120                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
121            },
122            expr::function::Function::LtEq => ast::Expr::BinaryOp {
123                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
124                op: ast::BinaryOperator::LtEq,
125                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
126            },
127            expr::function::Function::Eq => ast::Expr::BinaryOp {
128                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
129                op: ast::BinaryOperator::Eq,
130                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
131            },
132            expr::function::Function::NotEq => ast::Expr::BinaryOp {
133                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
134                op: ast::BinaryOperator::NotEq,
135                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
136            },
137            expr::function::Function::And => ast::Expr::BinaryOp {
138                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
139                op: ast::BinaryOperator::And,
140                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
141            },
142            expr::function::Function::Or => ast::Expr::BinaryOp {
143                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
144                op: ast::BinaryOperator::Or,
145                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
146            },
147            expr::function::Function::Xor => ast::Expr::BinaryOp {
148                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
149                op: ast::BinaryOperator::Xor,
150                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
151            },
152            expr::function::Function::BitwiseOr => ast::Expr::BinaryOp {
153                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
154                op: ast::BinaryOperator::BitwiseOr,
155                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
156            },
157            expr::function::Function::BitwiseAnd => ast::Expr::BinaryOp {
158                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
159                op: ast::BinaryOperator::BitwiseAnd,
160                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
161            },
162            expr::function::Function::BitwiseXor => ast::Expr::BinaryOp {
163                left: Box::new(ast::Expr::Nested(Box::new(arguments[0].clone()))),
164                op: ast::BinaryOperator::BitwiseXor,
165                right: Box::new(ast::Expr::Nested(Box::new(arguments[1].clone()))),
166            },
167            expr::function::Function::Exp
168            | expr::function::Function::Ln
169            | expr::function::Function::Log
170            | expr::function::Function::Abs
171            | expr::function::Function::Sin
172            | expr::function::Function::Cos
173            | expr::function::Function::Sqrt
174            | expr::function::Function::Pow
175            | expr::function::Function::Md5
176            | expr::function::Function::Concat(_)
177            | expr::function::Function::CharLength
178            | expr::function::Function::Lower
179            | expr::function::Function::Upper
180            | expr::function::Function::Random(_)
181            | expr::function::Function::Pi
182            | expr::function::Function::Least
183            | expr::function::Function::Greatest
184            | expr::function::Function::Coalesce
185            | expr::function::Function::Rtrim
186            | expr::function::Function::Ltrim
187            | expr::function::Function::Substr
188            | expr::function::Function::SubstrWithSize
189            | expr::function::Function::Ceil
190            | expr::function::Function::Floor
191            | expr::function::Function::Sign
192            | expr::function::Function::RegexpContains
193            | expr::function::Function::RegexpReplace
194            | expr::function::Function::Unhex
195            | expr::function::Function::Encode
196            | expr::function::Function::Decode
197            | expr::function::Function::Newid
198            | expr::function::Function::Dayname
199            | expr::function::Function::DateFormat
200            | expr::function::Function::Quarter
201            | expr::function::Function::DatetimeDiff
202            | expr::function::Function::Date
203            | expr::function::Function::FromUnixtime
204            | expr::function::Function::UnixTimestamp => {
205                let func_args_list = ast::FunctionArgumentList {
206                    duplicate_treatment: None,
207                    args: arguments
208                        .into_iter()
209                        .map(|e| ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(e)))
210                        .collect(),
211                    clauses: vec![],
212                };
213                ast::Expr::Function(ast::Function {
214                    name: ast::ObjectName(vec![ast::Ident::new(function.to_string())]),
215                    args: ast::FunctionArguments::List(func_args_list),
216                    over: None,
217                    filter: None,
218                    null_treatment: None,
219                    within_group: vec![],
220                })
221            }
222            expr::function::Function::RegexpExtract => {
223                let func_args_list = ast::FunctionArgumentList {
224                    duplicate_treatment: None,
225                    args: vec![
226                        arguments[0].clone(),
227                        arguments[1].clone(),
228                        arguments[2].clone(),
229                        arguments[3].clone(),
230                    ]
231                    .into_iter()
232                    .map(|e| ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(e)))
233                    .collect(),
234                    clauses: vec![],
235                };
236                ast::Expr::Function(ast::Function {
237                    name: ast::ObjectName(vec![ast::Ident::new(function.to_string())]),
238                    args: ast::FunctionArguments::List(func_args_list),
239                    over: None,
240                    filter: None,
241                    null_treatment: None,
242                    within_group: vec![],
243                })
244            }
245            expr::function::Function::Round | expr::function::Function::Trunc => {
246                let func_args_list = ast::FunctionArgumentList {
247                    duplicate_treatment: None,
248                    args: arguments
249                        .into_iter()
250                        .filter_map(|e| {
251                            (e != ast::Expr::Value(ast::Value::Number("0".to_string(), false)))
252                                .then_some(ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(e)))
253                        })
254                        .collect(),
255                    clauses: vec![],
256                };
257                ast::Expr::Function(ast::Function {
258                    name: ast::ObjectName(vec![ast::Ident::new(function.to_string())]),
259                    args: ast::FunctionArguments::List(func_args_list),
260                    over: None,
261                    filter: None,
262                    null_treatment: None,
263                    within_group: vec![],
264                })
265            }
266            expr::function::Function::Case => ast::Expr::Case {
267                operand: None,
268                conditions: vec![arguments[0].clone()],
269                results: vec![arguments[1].clone()],
270                else_result: Some(Box::new(arguments[2].clone())),
271            },
272            expr::function::Function::InList => {
273                if let ast::Expr::Tuple(t) = &arguments[1] {
274                    ast::Expr::InList {
275                        expr: arguments[0].clone().into(),
276                        list: t.clone(),
277                        negated: false,
278                    }
279                } else {
280                    todo!()
281                }
282            }
283            // a,
284            expr::function::Function::Position => ast::Expr::Position {
285                expr: arguments[0].clone().into(),
286                r#in: arguments[1].clone().into(),
287            },
288            expr::function::Function::CastAsText => ast::Expr::Cast {
289                expr: arguments[0].clone().into(),
290                data_type: DataType::text().into(),
291                format: None,
292                kind: ast::CastKind::Cast,
293            },
294            expr::function::Function::CastAsFloat => ast::Expr::Cast {
295                expr: arguments[0].clone().into(),
296                data_type: DataType::float().into(),
297                format: None,
298                kind: ast::CastKind::Cast,
299            },
300            expr::function::Function::CastAsInteger => ast::Expr::Cast {
301                expr: arguments[0].clone().into(),
302                data_type: DataType::integer().into(),
303                format: None,
304                kind: ast::CastKind::Cast,
305            },
306            expr::function::Function::CastAsBoolean => ast::Expr::Cast {
307                expr: arguments[0].clone().into(),
308                data_type: DataType::boolean().into(),
309                format: None,
310                kind: ast::CastKind::Cast,
311            },
312            expr::function::Function::CastAsDateTime => ast::Expr::Cast {
313                expr: arguments[0].clone().into(),
314                data_type: DataType::date_time().into(),
315                format: None,
316                kind: ast::CastKind::Cast,
317            },
318            expr::function::Function::CastAsDate => ast::Expr::Cast {
319                expr: arguments[0].clone().into(),
320                data_type: DataType::date().into(),
321                format: None,
322                kind: ast::CastKind::Cast,
323            },
324            expr::function::Function::CastAsTime => ast::Expr::Cast {
325                expr: arguments[0].clone().into(),
326                data_type: DataType::time().into(),
327                format: None,
328                kind: ast::CastKind::Cast,
329            },
330            expr::function::Function::CurrentDate
331            | expr::function::Function::CurrentTime
332            | expr::function::Function::CurrentTimestamp => ast::Expr::Function(ast::Function {
333                name: ast::ObjectName(vec![ast::Ident::new(function.to_string())]),
334                args: ast::FunctionArguments::None,
335                over: None,
336                filter: None,
337                null_treatment: None,
338                within_group: vec![],
339            }),
340            expr::function::Function::ExtractEpoch => ast::Expr::Extract {
341                field: ast::DateTimeField::Epoch,
342                expr: arguments[0].clone().into(),
343            },
344            expr::function::Function::ExtractYear => ast::Expr::Extract {
345                field: ast::DateTimeField::Year,
346                expr: arguments[0].clone().into(),
347            },
348            expr::function::Function::ExtractMonth => ast::Expr::Extract {
349                field: ast::DateTimeField::Month,
350                expr: arguments[0].clone().into(),
351            },
352            expr::function::Function::ExtractDay => ast::Expr::Extract {
353                field: ast::DateTimeField::Day,
354                expr: arguments[0].clone().into(),
355            },
356            expr::function::Function::ExtractHour => ast::Expr::Extract {
357                field: ast::DateTimeField::Hour,
358                expr: arguments[0].clone().into(),
359            },
360            expr::function::Function::ExtractMinute => ast::Expr::Extract {
361                field: ast::DateTimeField::Minute,
362                expr: arguments[0].clone().into(),
363            },
364            expr::function::Function::ExtractSecond => ast::Expr::Extract {
365                field: ast::DateTimeField::Second,
366                expr: arguments[0].clone().into(),
367            },
368            expr::function::Function::ExtractMicrosecond => ast::Expr::Extract {
369                field: ast::DateTimeField::Microsecond,
370                expr: arguments[0].clone().into(),
371            },
372            expr::function::Function::ExtractMillisecond => ast::Expr::Extract {
373                field: ast::DateTimeField::Millisecond,
374                expr: arguments[0].clone().into(),
375            },
376            expr::function::Function::ExtractDow => ast::Expr::Extract {
377                field: ast::DateTimeField::Dow,
378                expr: arguments[0].clone().into(),
379            },
380            expr::function::Function::ExtractWeek => ast::Expr::Extract {
381                field: ast::DateTimeField::Week(None),
382                expr: arguments[0].clone().into(),
383            },
384            expr::function::Function::Like => ast::Expr::Like {
385                negated: false,
386                expr: arguments[0].clone().into(),
387                pattern: arguments[1].clone().into(),
388                escape_char: None,
389            },
390            expr::function::Function::Ilike => ast::Expr::ILike {
391                negated: false,
392                expr: arguments[0].clone().into(),
393                pattern: arguments[1].clone().into(),
394                escape_char: None,
395            },
396            expr::function::Function::Choose => {
397                if let ast::Expr::Tuple(t) = &arguments[1] {
398                    let func_args_list = ast::FunctionArgumentList {
399                        duplicate_treatment: None,
400                        args: vec![arguments[0].clone()]
401                            .into_iter()
402                            .chain(t.clone())
403                            .map(|e| ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(e)))
404                            .collect(),
405                        clauses: vec![],
406                    };
407                    ast::Expr::Function(ast::Function {
408                        name: ast::ObjectName(vec![ast::Ident::new(function.to_string())]),
409                        args: ast::FunctionArguments::List(func_args_list),
410                        over: None,
411                        filter: None,
412                        null_treatment: None,
413                        within_group: vec![],
414                    })
415                } else {
416                    todo!()
417                }
418            }
419            expr::function::Function::IsNull => ast::Expr::IsNull(arguments[0].clone().into()),
420            expr::function::Function::IsBool => {
421                if let ast::Expr::Value(ast::Value::Boolean(b)) = arguments[1] {
422                    if b {
423                        ast::Expr::IsTrue(arguments[0].clone().into())
424                    } else {
425                        ast::Expr::IsFalse(arguments[0].clone().into())
426                    }
427                } else {
428                    unimplemented!()
429                }
430            }
431        }
432    }
433    // TODO implement this properly
434    fn aggregate(
435        &self,
436        aggregate: &'a expr::aggregate::Aggregate,
437        argument: ast::Expr,
438    ) -> ast::Expr {
439        match aggregate {
440            expr::aggregate::Aggregate::Min
441            | expr::aggregate::Aggregate::Max
442            | expr::aggregate::Aggregate::First
443            | expr::aggregate::Aggregate::Last
444            | expr::aggregate::Aggregate::Mean
445            | expr::aggregate::Aggregate::Count
446            | expr::aggregate::Aggregate::Sum
447            | expr::aggregate::Aggregate::Std => {
448                let func_args_list = ast::FunctionArgumentList {
449                    duplicate_treatment: None,
450                    args: vec![ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(
451                        argument,
452                    ))],
453                    clauses: vec![],
454                };
455                ast::Expr::Function(ast::Function {
456                    name: ast::ObjectName(vec![ast::Ident::new(aggregate.to_string())]),
457                    args: ast::FunctionArguments::List(func_args_list),
458                    over: None,
459                    filter: None,
460                    null_treatment: None,
461                    within_group: vec![],
462                })
463            }
464            expr::aggregate::Aggregate::Var => {
465                let func_args_list = ast::FunctionArgumentList {
466                    duplicate_treatment: None,
467                    args: vec![ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(
468                        argument,
469                    ))],
470                    clauses: vec![],
471                };
472                ast::Expr::Function(ast::Function {
473                    name: ast::ObjectName(vec![ast::Ident::new(String::from("variance"))]),
474                    args: ast::FunctionArguments::List(func_args_list),
475                    over: None,
476                    filter: None,
477                    null_treatment: None,
478                    within_group: vec![],
479                })
480            }
481            expr::aggregate::Aggregate::MeanDistinct => {
482                let func_args_list = ast::FunctionArgumentList {
483                    duplicate_treatment: Some(ast::DuplicateTreatment::Distinct),
484                    args: vec![ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(
485                        argument,
486                    ))],
487                    clauses: vec![],
488                };
489                ast::Expr::Function(ast::Function {
490                    name: ast::ObjectName(vec![ast::Ident::new(String::from("avg"))]),
491                    args: ast::FunctionArguments::List(func_args_list),
492                    over: None,
493                    filter: None,
494                    null_treatment: None,
495                    within_group: vec![],
496                })
497            }
498            expr::aggregate::Aggregate::CountDistinct => {
499                let func_args_list = ast::FunctionArgumentList {
500                    duplicate_treatment: Some(ast::DuplicateTreatment::Distinct),
501                    args: vec![ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(
502                        argument,
503                    ))],
504                    clauses: vec![],
505                };
506                ast::Expr::Function(ast::Function {
507                    name: ast::ObjectName(vec![ast::Ident::new(String::from("count"))]),
508                    args: ast::FunctionArguments::List(func_args_list),
509                    over: None,
510                    filter: None,
511                    null_treatment: None,
512                    within_group: vec![],
513                })
514            }
515            expr::aggregate::Aggregate::SumDistinct => {
516                let func_args_list = ast::FunctionArgumentList {
517                    duplicate_treatment: Some(ast::DuplicateTreatment::Distinct),
518                    args: vec![ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(
519                        argument,
520                    ))],
521                    clauses: vec![],
522                };
523                ast::Expr::Function(ast::Function {
524                    name: ast::ObjectName(vec![ast::Ident::new(String::from("sum"))]),
525                    args: ast::FunctionArguments::List(func_args_list),
526                    over: None,
527                    filter: None,
528                    null_treatment: None,
529                    within_group: vec![],
530                })
531            }
532            expr::aggregate::Aggregate::StdDistinct => {
533                let func_args_list = ast::FunctionArgumentList {
534                    duplicate_treatment: Some(ast::DuplicateTreatment::Distinct),
535                    args: vec![ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(
536                        argument,
537                    ))],
538                    clauses: vec![],
539                };
540                ast::Expr::Function(ast::Function {
541                    name: ast::ObjectName(vec![ast::Ident::new(String::from("stddev"))]),
542                    args: ast::FunctionArguments::List(func_args_list),
543                    over: None,
544                    filter: None,
545                    null_treatment: None,
546                    within_group: vec![],
547                })
548            }
549            expr::aggregate::Aggregate::VarDistinct => {
550                let func_args_list = ast::FunctionArgumentList {
551                    duplicate_treatment: Some(ast::DuplicateTreatment::Distinct),
552                    args: vec![ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(
553                        argument,
554                    ))],
555                    clauses: vec![],
556                };
557                ast::Expr::Function(ast::Function {
558                    name: ast::ObjectName(vec![ast::Ident::new(String::from("variance"))]),
559                    args: ast::FunctionArguments::List(func_args_list),
560                    over: None,
561                    filter: None,
562                    null_treatment: None,
563                    within_group: vec![],
564                })
565            }
566            expr::aggregate::Aggregate::Median => todo!(),
567            expr::aggregate::Aggregate::NUnique => todo!(),
568            expr::aggregate::Aggregate::List => todo!(),
569            expr::aggregate::Aggregate::Quantile(_) => todo!(),
570            expr::aggregate::Aggregate::Quantiles(_) => todo!(),
571            expr::aggregate::Aggregate::AggGroups => todo!(),
572        }
573    }
574
575    fn structured(&self, _fields: Vec<(expr::identifier::Identifier, ast::Expr)>) -> ast::Expr {
576        todo!()
577    }
578}
579
580/// Based on the FromExprVisitor implement the From trait
581impl From<&Expr> for ast::Expr {
582    fn from(value: &Expr) -> Self {
583        value.accept(FromExprVisitor)
584    }
585}
586
587#[cfg(test)]
588mod tests {
589    use super::*;
590    use crate::{hierarchy::Hierarchy, sql::parse_expr, WithoutContext};
591    use std::convert::TryFrom;
592
593    #[test]
594    fn test_from_expr() {
595        let ast_expr: ast::Expr = parse_expr("exp(a*cos(sin(x) + 2*a + b))").unwrap();
596        println!("ast::expr = {ast_expr}");
597        let expr = Expr::try_from(&ast_expr).unwrap();
598        println!("expr = {}", expr);
599        let gen_expr = ast::Expr::from(&expr);
600        println!("ast::expr = {gen_expr}");
601        //assert_eq!(ast_expr, gen_expr)
602        assert_eq!(
603            gen_expr.to_string(),
604            String::from("exp((a) * ((cos(((sin(x)) + ((2) * ((a)))) + (b)))))")
605        )
606    }
607
608    #[test]
609    fn test_from_expr_concat() {
610        let ast_expr: ast::Expr = parse_expr("concat(a, b, c)").unwrap();
611        println!("ast::expr = {ast_expr}");
612        let expr = Expr::try_from(&ast_expr).unwrap();
613        println!("expr = {}", expr);
614        let gen_expr = ast::Expr::from(&expr);
615        println!("ast::expr = {gen_expr}");
616        assert_eq!(ast_expr, gen_expr)
617    }
618
619    #[test]
620    fn test_string_functions() {
621        // Lower
622        let ast_expr: ast::Expr = parse_expr("lower(my_expr)").unwrap();
623        println!("ast::expr = {ast_expr}");
624        let expr = Expr::try_from(&ast_expr).unwrap();
625        println!("expr = {}", expr);
626        let gen_expr = ast::Expr::from(&expr);
627        assert_eq!(ast_expr, gen_expr);
628
629        // Upper
630        let ast_expr: ast::Expr = parse_expr("upper(my_expr)").unwrap();
631        println!("ast::expr = {ast_expr}");
632        let expr = Expr::try_from(&ast_expr).unwrap();
633        println!("expr = {}", expr);
634        let gen_expr = ast::Expr::from(&expr);
635        assert_eq!(ast_expr, gen_expr);
636
637        // CharLength
638        let ast_expr: ast::Expr = parse_expr("char_length(my_expr)").unwrap();
639        println!("ast::expr = {ast_expr}");
640        let expr = Expr::try_from(&ast_expr).unwrap();
641        println!("expr = {}", expr);
642        let gen_expr = ast::Expr::from(&expr);
643        assert_eq!(ast_expr, gen_expr);
644
645        // CharLength
646        let ast_expr: ast::Expr = parse_expr("position('x' in expr)").unwrap();
647        println!("ast::expr = {ast_expr}");
648        let expr = Expr::try_from(&ast_expr).unwrap();
649        println!("expr = {}", expr);
650        let gen_expr = ast::Expr::from(&expr);
651        assert_eq!(ast_expr, gen_expr);
652
653        // Newid
654        let ast_expr: ast::Expr = parse_expr("newid()").unwrap();
655        println!("ast::expr = {ast_expr}");
656        let expr = Expr::try_from(&ast_expr).unwrap();
657        println!("expr = {}", expr);
658        let gen_expr = ast::Expr::from(&expr);
659        assert_eq!(ast_expr, gen_expr);
660
661        // encode
662        let ast_expr: ast::Expr = parse_expr("encode(col1, col2)").unwrap();
663        println!("ast::expr = {ast_expr}");
664        let expr = Expr::try_from(&ast_expr).unwrap();
665        println!("expr = {}", expr);
666        let gen_expr = ast::Expr::from(&expr);
667        assert_eq!(ast_expr, gen_expr);
668
669        // decode
670        let ast_expr: ast::Expr = parse_expr("decode(col1, col2)").unwrap();
671        println!("ast::expr = {ast_expr}");
672        let expr = Expr::try_from(&ast_expr).unwrap();
673        println!("expr = {}", expr);
674        let gen_expr = ast::Expr::from(&expr);
675        assert_eq!(ast_expr, gen_expr);
676
677        // unhex
678        let ast_expr: ast::Expr = parse_expr("unhex(col1)").unwrap();
679        println!("ast::expr = {ast_expr}");
680        let expr = Expr::try_from(&ast_expr).unwrap();
681        println!("expr = {}", expr);
682        let gen_expr = ast::Expr::from(&expr);
683        assert_eq!(ast_expr, gen_expr);
684    }
685
686    #[test]
687    fn test_from_expr_with_var() {
688        let ast_expr: ast::Expr = parse_expr("variance((sin(x)) + (b))").unwrap();
689        println!("ast::expr = {ast_expr}");
690        let expr = Expr::try_from(&ast_expr).unwrap();
691        println!("expr = {}", expr);
692        let gen_expr = ast::Expr::from(&expr);
693        println!("ast::expr = {gen_expr}");
694        assert_eq!(ast_expr, gen_expr)
695    }
696
697    #[test]
698    fn test_case() {
699        let str_expr = "CASE a WHEN 5 THEN 0 ELSE a END";
700        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
701        println!("ast::expr = {ast_expr}");
702        assert_eq!(ast_expr.to_string(), str_expr.to_string(),);
703        let expr = Expr::try_from(&ast_expr).unwrap();
704        println!("expr = {}", expr);
705        assert_eq!(ast_expr.to_string(), str_expr.to_string(),);
706        let gen_expr = ast::Expr::from(&expr);
707        println!("ast::expr = {}", gen_expr.to_string());
708        assert_eq!(
709            gen_expr.to_string(),
710            "CASE WHEN (a) = (5) THEN 0 ELSE a END".to_string(),
711        );
712    }
713
714    #[test]
715    fn test_in() {
716        let str_expr = "a IN (4, 5)";
717        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
718        println!("ast::expr = {ast_expr}");
719        println!("ast::expr = {:?}", ast_expr);
720        assert_eq!(ast_expr.to_string(), str_expr.to_string(),);
721        let expr = Expr::try_from(&ast_expr).unwrap();
722        println!("expr = {}", expr);
723        println!("expr = {:?}", expr);
724        assert_eq!(ast_expr.to_string(), str_expr.to_string(),);
725        let gen_expr = ast::Expr::from(&expr);
726        println!("ast::expr = {}", gen_expr.to_string());
727        assert_eq!(gen_expr.to_string(), "a IN (4, 5)".to_string(),);
728    }
729
730    #[test]
731    fn test_coalesce() {
732        let str_expr = "Coalesce(a, 5)";
733        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
734        println!("ast::expr = {ast_expr}");
735        println!("ast::expr = {:?}", ast_expr);
736        assert_eq!(ast_expr.to_string(), str_expr.to_string(),);
737    }
738
739    #[test]
740    fn test_substr() {
741        let str_expr = "substr(a, 5, 2)";
742        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
743        let expr = Expr::try_from(&ast_expr).unwrap();
744        println!("expr = {}", expr);
745        let gen_expr = ast::Expr::from(&expr);
746        println!("ast::expr = {gen_expr}");
747        assert_eq!(ast_expr, gen_expr);
748
749        let str_expr = "\nsubstr(a, 5)";
750        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
751        let expr = Expr::try_from(&ast_expr).unwrap();
752        println!("expr = {}", expr);
753        let gen_expr = ast::Expr::from(&expr);
754        println!("ast::expr = {gen_expr}");
755        assert_eq!(ast_expr, gen_expr);
756
757        let str_expr = "\nsubstring(a from 5 for 2)";
758        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
759        let expr = Expr::try_from(&ast_expr).unwrap();
760        println!("expr = {}", expr);
761        let gen_expr = ast::Expr::from(&expr);
762        println!("ast::expr = {gen_expr}");
763        assert_eq!(gen_expr, parse_expr("substr(a, 5, 2)").unwrap());
764
765        let str_expr = "\nsubstring(a from 5)";
766        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
767        let expr = Expr::try_from(&ast_expr).unwrap();
768        println!("expr = {}", expr);
769        let gen_expr = ast::Expr::from(&expr);
770        println!("ast::expr = {gen_expr}");
771        assert_eq!(gen_expr, parse_expr("substr(a, 5)").unwrap());
772
773        let str_expr = "\nsubstring(a for 5)";
774        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
775        let expr = Expr::try_from(&ast_expr).unwrap();
776        println!("expr = {}", expr);
777        let gen_expr = ast::Expr::from(&expr);
778        println!("ast::expr = {gen_expr}");
779        assert_eq!(gen_expr, parse_expr("substr(a, 0, 5)").unwrap());
780    }
781
782    #[test]
783    fn test_cast() {
784        let str_expr = "cast(a as varchar)";
785        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
786        let expr = Expr::try_from(&ast_expr).unwrap();
787        println!("expr = {}", expr);
788        let gen_expr = ast::Expr::from(&expr);
789        println!("ast::expr = {gen_expr}");
790        assert_eq!(ast_expr, gen_expr);
791
792        let str_expr = "cast(a as bigint)";
793        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
794        let expr = Expr::try_from(&ast_expr).unwrap();
795        println!("expr = {}", expr);
796        let gen_expr = ast::Expr::from(&expr);
797        println!("ast::expr = {gen_expr}");
798        assert_eq!(ast_expr, gen_expr);
799
800        let str_expr = "cast(a as boolean)";
801        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
802        let expr = Expr::try_from(&ast_expr).unwrap();
803        println!("expr = {}", expr);
804        let gen_expr = ast::Expr::from(&expr);
805        println!("ast::expr = {gen_expr}");
806        assert_eq!(ast_expr, gen_expr);
807
808        let str_expr = "cast(a as float)";
809        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
810        let expr = Expr::try_from(&ast_expr).unwrap();
811        println!("expr = {}", expr);
812        let gen_expr = ast::Expr::from(&expr);
813        println!("ast::expr = {gen_expr}");
814        assert_eq!(ast_expr, gen_expr);
815
816        let str_expr = "cast(a as date)";
817        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
818        let expr = Expr::try_from(&ast_expr).unwrap();
819        println!("expr = {}", expr);
820        let gen_expr = ast::Expr::from(&expr);
821        println!("ast::expr = {gen_expr}");
822        assert_eq!(ast_expr, gen_expr);
823
824        let str_expr = "cast(a as time)";
825        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
826        let expr = Expr::try_from(&ast_expr).unwrap();
827        println!("expr = {}", expr);
828        let gen_expr = ast::Expr::from(&expr);
829        println!("ast::expr = {gen_expr}");
830        assert_eq!(ast_expr, gen_expr);
831
832        let str_expr = "cast(a as timestamp)";
833        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
834        let expr = Expr::try_from(&ast_expr).unwrap();
835        println!("expr = {}", expr);
836        let gen_expr = ast::Expr::from(&expr);
837        println!("ast::expr = {gen_expr}");
838        assert_eq!(ast_expr, gen_expr);
839    }
840
841    #[test]
842    fn test_ceil() {
843        let str_expr = "ceil(a)";
844        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
845        let expr = Expr::try_from(&ast_expr).unwrap();
846        println!("expr = {}", expr);
847        let gen_expr = ast::Expr::from(&expr);
848        println!("ast::expr = {gen_expr}");
849        assert_eq!(
850            ast_expr.to_string().to_lowercase(),
851            gen_expr.to_string().to_lowercase()
852        );
853    }
854
855    #[test]
856    fn test_floor() {
857        let str_expr = "floor(a)";
858        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
859        let expr = Expr::try_from(&ast_expr).unwrap();
860        println!("expr = {}", expr);
861        let gen_expr = ast::Expr::from(&expr);
862        println!("ast::expr = {gen_expr}");
863        assert_eq!(
864            ast_expr.to_string().to_lowercase(),
865            gen_expr.to_string().to_lowercase()
866        );
867    }
868
869    #[test]
870    fn test_round() {
871        let str_expr = "round(a)";
872        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
873        let expr = Expr::try_from(&ast_expr).unwrap();
874        println!("expr = {}", expr);
875        let gen_expr = ast::Expr::from(&expr);
876        println!("ast::expr = {gen_expr}");
877        assert_eq!(
878            ast_expr.to_string().to_lowercase(),
879            gen_expr.to_string().to_lowercase()
880        );
881
882        let str_expr = "round(a, 1)";
883        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
884        let expr = Expr::try_from(&ast_expr).unwrap();
885        println!("expr = {}", expr);
886        let gen_expr = ast::Expr::from(&expr);
887        println!("ast::expr = {gen_expr}");
888        assert_eq!(
889            ast_expr.to_string().to_lowercase(),
890            gen_expr.to_string().to_lowercase()
891        );
892
893        let str_expr = "round(a, 1)";
894        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
895        let expr = Expr::try_from(&ast_expr).unwrap();
896        println!("expr = {}", expr);
897        let gen_expr = ast::Expr::from(&expr);
898        println!("ast::expr = {gen_expr}");
899        assert_eq!(
900            ast_expr.to_string().to_lowercase(),
901            gen_expr.to_string().to_lowercase()
902        );
903    }
904
905    #[test]
906    fn test_trunc() {
907        let str_expr = "trunc(a)";
908        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
909        let expr = Expr::try_from(&ast_expr).unwrap();
910        println!("expr = {}", expr);
911        let gen_expr = ast::Expr::from(&expr);
912        println!("ast::expr = {gen_expr}");
913        assert_eq!(
914            ast_expr.to_string().to_lowercase(),
915            gen_expr.to_string().to_lowercase()
916        );
917
918        let str_expr = "trunc(a, 1)";
919        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
920        let expr = Expr::try_from(&ast_expr).unwrap();
921        println!("expr = {}", expr);
922        let gen_expr = ast::Expr::from(&expr);
923        println!("ast::expr = {gen_expr}");
924        assert_eq!(
925            ast_expr.to_string().to_lowercase(),
926            gen_expr.to_string().to_lowercase()
927        );
928
929        let str_expr = "trunc(a, 4)";
930        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
931        let expr = Expr::try_from(&ast_expr).unwrap();
932        println!("expr = {}", expr);
933        let gen_expr = ast::Expr::from(&expr);
934        println!("ast::expr = {gen_expr}");
935        assert_eq!(
936            ast_expr.to_string().to_lowercase(),
937            gen_expr.to_string().to_lowercase()
938        );
939    }
940
941    #[test]
942    fn test_sign() {
943        let str_expr = "sign(a)";
944        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
945        let expr = Expr::try_from(&ast_expr).unwrap();
946        println!("expr = {}", expr);
947        let gen_expr = ast::Expr::from(&expr);
948        println!("ast::expr = {gen_expr}");
949        assert_eq!(ast_expr, gen_expr);
950    }
951
952    #[test]
953    fn test_square() {
954        let str_expr = "square(x)";
955        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
956        let expr = Expr::try_from(&ast_expr).unwrap();
957        println!("expr = {}", expr);
958        let gen_expr = ast::Expr::from(&expr);
959        let true_expr = parse_expr("pow(x, 2)").unwrap();
960        assert_eq!(gen_expr, true_expr);
961    }
962
963    #[test]
964    fn test_log() {
965        let str_expr = "ln(x)";
966        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
967        let expr = Expr::try_from(&ast_expr).unwrap();
968        println!("expr = {}", expr);
969        let gen_expr = ast::Expr::from(&expr);
970        println!("ast::expr = {gen_expr}");
971        assert_eq!(ast_expr, gen_expr);
972
973        let str_expr = "log(x)";
974        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
975        let expr = Expr::try_from(&ast_expr).unwrap();
976        println!("expr = {}", expr);
977        let gen_expr = ast::Expr::from(&expr);
978        println!("ast::expr = {gen_expr}");
979        assert_eq!(ast_expr, gen_expr);
980
981        let epsilon = 1. / f64::MAX;
982
983        let str_expr = "log(b, x)";
984        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
985        let expr = Expr::try_from(&ast_expr).unwrap();
986        println!("expr = {}", expr);
987        let gen_expr = ast::Expr::from(&expr);
988        println!("ast::expr = {gen_expr}");
989        let true_expr = parse_expr(
990            format!(
991                "CASE WHEN ((log(b)) >= ({})) OR ((log(b)) <= (-({})))
992            THEN (log(x)) / ((log(b))) ELSE 0 END",
993                epsilon, epsilon
994            )
995            .as_str(),
996        )
997        .unwrap();
998        assert_eq!(gen_expr, true_expr);
999
1000        let str_expr = "log10(x)";
1001        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1002        let expr = Expr::try_from(&ast_expr).unwrap();
1003        println!("expr = {}", expr);
1004        let gen_expr = ast::Expr::from(&expr);
1005        let true_expr = parse_expr(
1006            format!(
1007                "CASE WHEN ((log(x)) >= ({})) OR ((log(x)) <= (-({})))
1008            THEN (log(10)) / ((log(x))) ELSE 0 END",
1009                epsilon, epsilon
1010            )
1011            .as_str(),
1012        )
1013        .unwrap();
1014        assert_eq!(gen_expr, true_expr);
1015
1016        let str_expr = "log2(x)";
1017        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1018        let expr = Expr::try_from(&ast_expr).unwrap();
1019        println!("expr = {}", expr);
1020        let gen_expr = ast::Expr::from(&expr);
1021        println!("ast::expr = {gen_expr}");
1022        let true_expr = parse_expr(
1023            format!(
1024                "CASE WHEN ((log(x)) >= ({})) OR ((log(x)) <= (-({})))
1025            THEN (log(2)) / ((log(x))) ELSE 0 END",
1026                epsilon, epsilon
1027            )
1028            .as_str(),
1029        )
1030        .unwrap();
1031        assert_eq!(gen_expr, true_expr);
1032    }
1033
1034    #[test]
1035    fn test_trigo() {
1036        let str_expr = "sin(x)";
1037        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1038        let expr = Expr::try_from(&ast_expr).unwrap();
1039        println!("expr = {}", expr);
1040        let gen_expr = ast::Expr::from(&expr);
1041        println!("ast::expr = {gen_expr}");
1042        assert_eq!(ast_expr, gen_expr);
1043
1044        let str_expr = "cos(x)";
1045        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1046        let expr = Expr::try_from(&ast_expr).unwrap();
1047        println!("expr = {}", expr);
1048        let gen_expr = ast::Expr::from(&expr);
1049        println!("ast::expr = {gen_expr}");
1050        assert_eq!(ast_expr, gen_expr);
1051
1052        let epsilon = 1. / f64::MAX;
1053        let str_expr = "tan(x)";
1054        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1055        let expr = Expr::try_from(&ast_expr).unwrap();
1056        println!("expr = {}", expr);
1057        let gen_expr = ast::Expr::from(&expr);
1058        println!("ast::expr = {gen_expr}");
1059        let true_expr = parse_expr(
1060            format!(
1061                "CASE WHEN ((cos(x)) >= ({})) OR ((cos(x)) <= (-({})))
1062            THEN (sin(x)) / ((cos(x))) ELSE 0 END",
1063                epsilon, epsilon
1064            )
1065            .as_str(),
1066        )
1067        .unwrap();
1068        assert_eq!(gen_expr, true_expr);
1069    }
1070
1071    #[test]
1072    fn test_random() {
1073        let str_expr = "random()";
1074        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1075        let expr = Expr::try_from(&ast_expr).unwrap();
1076        println!("expr = {}", expr);
1077        let gen_expr = ast::Expr::from(&expr);
1078        println!("ast::expr = {gen_expr}");
1079        assert_eq!(ast_expr, gen_expr);
1080    }
1081
1082    #[test]
1083    fn test_pi() {
1084        let str_expr = "pi()";
1085        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1086        let expr = Expr::try_from(&ast_expr).unwrap();
1087        println!("expr = {}", expr);
1088        let gen_expr = ast::Expr::from(&expr);
1089        println!("ast::expr = {gen_expr}");
1090        assert_eq!(ast_expr, gen_expr);
1091    }
1092
1093    #[test]
1094    fn test_degrees() {
1095        let str_expr = "degrees(100)";
1096        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1097        let expr = Expr::try_from(&ast_expr).unwrap();
1098        println!("expr = {}", expr);
1099        let gen_expr = ast::Expr::from(&expr);
1100        println!("ast::expr = {gen_expr}");
1101        let epsilon = 1. / f64::MAX;
1102        let true_expr = parse_expr(
1103            format!(
1104                "(100) * ((CASE WHEN  ((pi()) >= ({})) OR  ((pi()) <= (-({})))
1105            THEN (180) / ((pi())) ELSE 0 END))",
1106                epsilon, epsilon
1107            )
1108            .as_str(),
1109        )
1110        .unwrap();
1111        assert_eq!(gen_expr, true_expr);
1112    }
1113
1114    #[test]
1115    fn test_regexp_contains() {
1116        let str_expr = "regexp_contains(col1, col2)";
1117        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1118        let expr = Expr::try_from(&ast_expr).unwrap();
1119        println!("expr = {}", expr);
1120        let gen_expr = ast::Expr::from(&expr);
1121        println!("ast::expr = {gen_expr}");
1122        assert_eq!(ast_expr, gen_expr);
1123    }
1124
1125    #[test]
1126    fn test_regexp_extract() {
1127        let str_expr = "regexp_extract(value, regexp)";
1128        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1129        let expr = Expr::try_from(&ast_expr).unwrap();
1130        println!("expr = {}", expr);
1131        let gen_expr = ast::Expr::from(&expr);
1132        println!("ast::expr = {gen_expr}");
1133        let true_expr = parse_expr("regexp_extract(value, regexp, 0, 1)").unwrap();
1134        assert_eq!(gen_expr, true_expr);
1135
1136        let str_expr = "regexp_substr(value, regexp)";
1137        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1138        let expr = Expr::try_from(&ast_expr).unwrap();
1139        println!("expr = {}", expr);
1140        let gen_expr = ast::Expr::from(&expr);
1141        println!("ast::expr = {gen_expr}");
1142        let true_expr = parse_expr("regexp_extract(value, regexp, 0, 1)").unwrap();
1143        assert_eq!(gen_expr, true_expr);
1144
1145        let str_expr = "regexp_extract(value, regexp, position)";
1146        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1147        let expr = Expr::try_from(&ast_expr).unwrap();
1148        println!("expr = {}", expr);
1149        let gen_expr = ast::Expr::from(&expr);
1150        println!("ast::expr = {gen_expr}");
1151        let true_expr = parse_expr("regexp_extract(value, regexp, position, 1)").unwrap();
1152        assert_eq!(gen_expr, true_expr);
1153
1154        let str_expr = "regexp_substr(value, regexp, position)";
1155        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1156        let expr = Expr::try_from(&ast_expr).unwrap();
1157        println!("expr = {}", expr);
1158        let gen_expr = ast::Expr::from(&expr);
1159        println!("ast::expr = {gen_expr}");
1160        let true_expr = parse_expr("regexp_extract(value, regexp, position, 1)").unwrap();
1161        assert_eq!(gen_expr, true_expr);
1162
1163        let str_expr = "regexp_extract(value, regexp, position, occurrence)";
1164        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1165        let expr = Expr::try_from(&ast_expr).unwrap();
1166        println!("expr = {}", expr);
1167        let gen_expr = ast::Expr::from(&expr);
1168        println!("ast::expr = {gen_expr}");
1169        assert_eq!(gen_expr, ast_expr);
1170    }
1171
1172    #[test]
1173    fn test_regexp_replace() {
1174        let str_expr = "regexp_replace(value, regexp, replacement)";
1175        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1176        let expr = Expr::try_from(&ast_expr).unwrap();
1177        println!("expr = {}", expr);
1178        let gen_expr = ast::Expr::from(&expr);
1179        println!("ast::expr = {gen_expr}");
1180        let true_expr = parse_expr("regexp_replace(value, regexp, replacement)").unwrap();
1181        assert_eq!(gen_expr, true_expr);
1182    }
1183
1184    #[test]
1185    fn test_current() {
1186        // CURRENT_DATE
1187        let str_expr = "current_date";
1188        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1189        let expr = Expr::try_from(&ast_expr).unwrap();
1190        println!("expr = {}", expr);
1191        let gen_expr = ast::Expr::from(&expr);
1192        println!("ast::expr = {gen_expr}");
1193        assert_eq!(gen_expr, ast_expr);
1194
1195        // CURRENT_TIME
1196        let str_expr = "current_time";
1197        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1198        let expr = Expr::try_from(&ast_expr).unwrap();
1199        println!("expr = {}", expr);
1200        let gen_expr = ast::Expr::from(&expr);
1201        println!("ast::expr = {gen_expr}");
1202        assert_eq!(gen_expr, ast_expr);
1203
1204        // CURRENT_TIMESTAMP
1205        let str_expr = "current_timestamp";
1206        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1207        let expr = Expr::try_from(&ast_expr).unwrap();
1208        println!("expr = {}", expr);
1209        let gen_expr = ast::Expr::from(&expr);
1210        println!("ast::expr = {gen_expr}");
1211        assert_eq!(gen_expr, ast_expr);
1212    }
1213
1214    #[test]
1215    fn test_extract() {
1216        // EXTRACT(EPOCH FROM col1)
1217        let str_expr = "extract(epoch from col1)";
1218        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1219        let expr = Expr::try_from(&ast_expr).unwrap();
1220        println!("expr = {}", expr);
1221        let gen_expr = ast::Expr::from(&expr);
1222        println!("ast::expr = {gen_expr}");
1223        assert_eq!(gen_expr, ast_expr);
1224
1225        // EXTRACT(YEAR FROM col1)
1226        let str_expr = "extract(year from col1)";
1227        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1228        let expr = Expr::try_from(&ast_expr).unwrap();
1229        println!("expr = {}", expr);
1230        let gen_expr = ast::Expr::from(&expr);
1231        println!("ast::expr = {gen_expr}");
1232        assert_eq!(gen_expr, ast_expr);
1233
1234        // EXTRACT(MONTH FROM col1)
1235        let str_expr = "extract(month from col1)";
1236        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1237        let expr = Expr::try_from(&ast_expr).unwrap();
1238        println!("expr = {}", expr);
1239        let gen_expr = ast::Expr::from(&expr);
1240        println!("ast::expr = {gen_expr}");
1241        assert_eq!(gen_expr, ast_expr);
1242
1243        // EXTRACT(DAY FROM col1)
1244        let str_expr = "extract(day from col1)";
1245        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1246        let expr = Expr::try_from(&ast_expr).unwrap();
1247        println!("expr = {}", expr);
1248        let gen_expr = ast::Expr::from(&expr);
1249        println!("ast::expr = {gen_expr}");
1250        assert_eq!(gen_expr, ast_expr);
1251
1252        // EXTRACT(HOUR FROM col1)
1253        let str_expr = "extract(hour from col1)";
1254        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1255        let expr = Expr::try_from(&ast_expr).unwrap();
1256        println!("expr = {}", expr);
1257        let gen_expr = ast::Expr::from(&expr);
1258        println!("ast::expr = {gen_expr}");
1259        assert_eq!(gen_expr, ast_expr);
1260
1261        // EXTRACT(MINUTE FROM col1)
1262        let str_expr = "extract(minute from col1)";
1263        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1264        let expr = Expr::try_from(&ast_expr).unwrap();
1265        println!("expr = {}", expr);
1266        let gen_expr = ast::Expr::from(&expr);
1267        println!("ast::expr = {gen_expr}");
1268        assert_eq!(gen_expr, ast_expr);
1269
1270        // EXTRACT(SECOND FROM col1)
1271        let str_expr = "extract(second from col1)";
1272        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1273        let expr = Expr::try_from(&ast_expr).unwrap();
1274        println!("expr = {}", expr);
1275        let gen_expr = ast::Expr::from(&expr);
1276        println!("ast::expr = {gen_expr}");
1277        assert_eq!(gen_expr, ast_expr);
1278
1279        // EXTRACT(MICROSECOND FROM col1)
1280        let str_expr = "extract(microsecond from col1)";
1281        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1282        let expr = Expr::try_from(&ast_expr).unwrap();
1283        println!("expr = {}", expr);
1284        let gen_expr = ast::Expr::from(&expr);
1285        println!("ast::expr = {gen_expr}");
1286        assert_eq!(gen_expr, ast_expr);
1287
1288        // EXTRACT(MILLISECOND FROM col1)
1289        let str_expr = "extract(millisecond from col1)";
1290        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1291        let expr = Expr::try_from(&ast_expr).unwrap();
1292        println!("expr = {}", expr);
1293        let gen_expr = ast::Expr::from(&expr);
1294        println!("ast::expr = {gen_expr}");
1295        assert_eq!(gen_expr, ast_expr);
1296
1297        // EXTRACT(DOW FROM col1)
1298        let str_expr = "extract(dow from col1)";
1299        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1300        let expr = Expr::try_from(&ast_expr).unwrap();
1301        println!("expr = {}", expr);
1302        let gen_expr = ast::Expr::from(&expr);
1303        println!("ast::expr = {gen_expr}");
1304        assert_eq!(gen_expr, ast_expr);
1305
1306        // EXTRACT(WEEK FROM col1)
1307        let str_expr = "extract(week from col1)";
1308        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1309        let expr = Expr::try_from(&ast_expr).unwrap();
1310        println!("expr = {}", expr);
1311        let gen_expr = ast::Expr::from(&expr);
1312        println!("ast::expr = {gen_expr}");
1313        assert_eq!(gen_expr, ast_expr);
1314    }
1315
1316    #[test]
1317    fn test_datetime_functions() {
1318        // DAYNAME
1319        let str_expr = "dayname(col1)";
1320        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1321        let expr = Expr::try_from(&ast_expr).unwrap();
1322        println!("expr = {}", expr);
1323        let gen_expr = ast::Expr::from(&expr);
1324        println!("ast::expr = {gen_expr}");
1325        assert_eq!(gen_expr, ast_expr);
1326
1327        // DATE_FORMAT
1328        let str_expr = "date_format(col1, format_date)";
1329        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1330        let expr = Expr::try_from(&ast_expr).unwrap();
1331        println!("expr = {}", expr);
1332        let gen_expr = ast::Expr::from(&expr);
1333        println!("ast::expr = {gen_expr}");
1334        assert_eq!(gen_expr, ast_expr);
1335
1336        // Quarter
1337        let str_expr = "quarter(col1)";
1338        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1339        let expr = Expr::try_from(&ast_expr).unwrap();
1340        println!("expr = {}", expr);
1341        let gen_expr = ast::Expr::from(&expr);
1342        println!("ast::expr = {gen_expr}");
1343        assert_eq!(gen_expr, ast_expr);
1344
1345        // datetime_diff
1346        let str_expr = "datetime_diff(col1, col2, col3)";
1347        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1348        let expr = Expr::try_from(&ast_expr).unwrap();
1349        println!("expr = {}", expr);
1350        let gen_expr = ast::Expr::from(&expr);
1351        println!("ast::expr = {gen_expr}");
1352        assert_eq!(gen_expr, ast_expr);
1353
1354        // date
1355        let str_expr = "date(col1)";
1356        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1357        let expr = Expr::try_from(&ast_expr).unwrap();
1358        println!("expr = {}", expr);
1359        let gen_expr = ast::Expr::from(&expr);
1360        println!("ast::expr = {gen_expr}");
1361        assert_eq!(gen_expr, ast_expr);
1362
1363        // from_unixtime
1364        let str_expr = "from_unixtime(col1, '%Y-%m-%d')";
1365        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1366        let expr = Expr::try_from(&ast_expr).unwrap();
1367        println!("expr = {}", expr);
1368        let gen_expr = ast::Expr::from(&expr);
1369        println!("ast::expr = {gen_expr}");
1370        assert_eq!(gen_expr, ast_expr);
1371
1372        let str_expr = "from_unixtime(col1)";
1373        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1374        let expr = Expr::try_from(&ast_expr).unwrap();
1375        println!("expr = {}", expr);
1376        let gen_expr = ast::Expr::from(&expr);
1377        println!("ast::expr = {gen_expr}");
1378        let true_expr = parse_expr("from_unixtime(col1, '%Y-%m-%d %H:%i:%S')").unwrap();
1379        assert_eq!(gen_expr, true_expr);
1380
1381        // unix_timestamp
1382        let str_expr = "unix_timestamp(col1)";
1383        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1384        let expr = Expr::try_from(&ast_expr).unwrap();
1385        println!("expr = {}", expr);
1386        let gen_expr = ast::Expr::from(&expr);
1387        println!("ast::expr = {gen_expr}");
1388        assert_eq!(gen_expr, ast_expr);
1389
1390        let str_expr = "unix_timestamp()";
1391        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1392        let expr = Expr::try_from(&ast_expr).unwrap();
1393        println!("expr = {}", expr);
1394        let gen_expr = ast::Expr::from(&expr);
1395        println!("ast::expr = {gen_expr}");
1396        let true_expr = parse_expr("unix_timestamp(current_timestamp)").unwrap();
1397        assert_eq!(gen_expr, true_expr);
1398    }
1399
1400    #[test]
1401    fn test_boolean_expressions() {
1402        // like
1403        let str_expr = "col1 LIKE 'a%'";
1404        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1405        let expr = Expr::try_from(&ast_expr).unwrap();
1406        println!("expr = {}", expr);
1407        let gen_expr = ast::Expr::from(&expr);
1408        println!("ast::expr = {gen_expr}");
1409        assert_eq!(gen_expr, ast_expr);
1410
1411        let str_expr = "col1 NOT LIKE 'a%'";
1412        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1413        let expr = Expr::try_from(&ast_expr).unwrap();
1414        println!("expr = {}", expr);
1415        let gen_expr = ast::Expr::from(&expr);
1416        let true_expr = parse_expr("not(col1 LIKE 'a%')").unwrap();
1417        assert_eq!(gen_expr, true_expr);
1418
1419        // ilike
1420        let str_expr = "col1 ILIKE 'a%'";
1421        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1422        let expr = Expr::try_from(&ast_expr).unwrap();
1423        println!("expr = {}", expr);
1424        let gen_expr = ast::Expr::from(&expr);
1425        println!("ast::expr = {gen_expr}");
1426        assert_eq!(gen_expr, ast_expr);
1427
1428        let str_expr = "col1 NOT ILIKE 'a%'";
1429        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1430        let expr = Expr::try_from(&ast_expr).unwrap();
1431        println!("expr = {}", expr);
1432        let gen_expr = ast::Expr::from(&expr);
1433        let true_expr = parse_expr("not(col1 ILIKE 'a%')").unwrap();
1434        assert_eq!(gen_expr, true_expr);
1435
1436        // Between
1437        let str_expr = "Price BETWEEN 10 AND 20";
1438        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1439        let expr = Expr::try_from(&ast_expr).unwrap();
1440        println!("expr = {}", expr);
1441        let gen_expr = ast::Expr::from(&expr);
1442        let true_expr = parse_expr("((price) >= (10)) AND ((price) <= (20))").unwrap();
1443        assert_eq!(gen_expr, true_expr);
1444
1445        // IS
1446        let str_expr = "col1 IS null";
1447        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1448        let expr = Expr::try_from(&ast_expr).unwrap();
1449        println!("expr = {}", expr);
1450        let gen_expr = ast::Expr::from(&expr);
1451        assert_eq!(gen_expr, ast_expr);
1452
1453        let str_expr = "col1 IS NOT null";
1454        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1455        let expr = Expr::try_from(&ast_expr).unwrap();
1456        println!("expr = {}", expr);
1457        let gen_expr = ast::Expr::from(&expr);
1458        let true_expr = parse_expr("not (col1 IS null)").unwrap();
1459        assert_eq!(gen_expr, true_expr);
1460
1461        let str_expr = "col1 IS true";
1462        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1463        let expr = Expr::try_from(&ast_expr).unwrap();
1464        println!("expr = {}", expr);
1465        let gen_expr = ast::Expr::from(&expr);
1466        let true_expr = parse_expr("cast(col1 as boolean) IS true)").unwrap();
1467        assert_eq!(gen_expr, true_expr);
1468
1469        let str_expr = "col1 IS NOT true";
1470        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1471        let expr = Expr::try_from(&ast_expr).unwrap();
1472        println!("expr = {}", expr);
1473        let gen_expr = ast::Expr::from(&expr);
1474        let true_expr = parse_expr("not (cast(col1 as boolean) IS true)").unwrap();
1475        assert_eq!(gen_expr, true_expr);
1476
1477        let str_expr = "col1 IS false";
1478        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1479        let expr = Expr::try_from(&ast_expr).unwrap();
1480        println!("expr = {}", expr);
1481        let gen_expr = ast::Expr::from(&expr);
1482        let true_expr = parse_expr("cast(col1 as boolean) IS false)").unwrap();
1483        assert_eq!(gen_expr, true_expr);
1484
1485        let str_expr = "col1 IS NOT false";
1486        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1487        let expr = Expr::try_from(&ast_expr).unwrap();
1488        println!("expr = {}", expr);
1489        let gen_expr = ast::Expr::from(&expr);
1490        let true_expr = parse_expr("not (cast(col1 as boolean) IS false)").unwrap();
1491        assert_eq!(gen_expr, true_expr);
1492    }
1493
1494    #[test]
1495    fn test_choose() {
1496        let str_expr = "choose(3, 'a', 'b', 'c')";
1497        let ast_expr: ast::Expr = parse_expr(str_expr).unwrap();
1498        let expr = Expr::try_from(&ast_expr).unwrap();
1499        println!("expr = {}", expr);
1500        let gen_expr = ast::Expr::from(&expr);
1501        println!("ast::expr = {gen_expr}");
1502        assert_eq!(gen_expr, ast_expr);
1503    }
1504
1505    #[test]
1506    fn test_expr_from_value() {
1507        let ast_expr: ast::Expr = parse_expr("True").unwrap();
1508        println!("\nast::expr = {ast_expr}");
1509        let expr = Expr::try_from(ast_expr.with(&Hierarchy::empty())).unwrap();
1510        println!("expr = {}", expr);
1511
1512        let ast_expr: ast::Expr = parse_expr("1").unwrap();
1513        println!("\nast::expr = {ast_expr}");
1514        let expr = Expr::try_from(ast_expr.with(&Hierarchy::empty())).unwrap();
1515        println!("expr = {}", expr);
1516
1517        let ast_expr: ast::Expr = parse_expr("Null").unwrap();
1518        println!("\nast::expr = {ast_expr}");
1519        let expr = Expr::try_from(ast_expr.with(&Hierarchy::empty())).unwrap();
1520        println!("expr = {}", expr);
1521
1522        let ast_expr: ast::Expr = parse_expr(" 'some_string' ").unwrap();
1523        println!("\nast::expr = {ast_expr}");
1524        let expr = Expr::try_from(ast_expr.with(&Hierarchy::empty())).unwrap();
1525        println!("expr = {}", expr);
1526    }
1527}
qrlew/expr/sql.rs

qrlew/expr/
sql.rs
