Expr:Function(Box<Function>)

Author: xitep

src/ast/mod.rs

@@ -1014,6 +1014,7 @@ pub enum Expr {
         expr: Box<Expr>,
     },
     /// CONVERT a value to a different data type or character encoding. e.g. `CONVERT(foo USING utf8mb4)`
+    // XXX too big
     Convert {
         /// CONVERT (false) or TRY_CONVERT (true)
         /// <https://learn.microsoft.com/en-us/sql/t-sql/functions/try-convert-transact-sql?view=sql-server-ver16>
@@ -1032,6 +1033,7 @@ pub enum Expr {
         styles: Vec<Expr>,
     },
     /// `CAST` an expression to a different data type e.g. `CAST(foo AS VARCHAR(123))`
+    // XXX too big
     Cast {
         /// The cast kind (e.g., `CAST`, `TRY_CAST`).
         kind: CastKind,
@@ -1181,14 +1183,17 @@ pub enum Expr {
     /// A constant of form `<data_type> 'value'`.
     /// This can represent ANSI SQL `DATE`, `TIME`, and `TIMESTAMP` literals (such as `DATE '2020-01-01'`),
     /// as well as constants of other types (a non-standard PostgreSQL extension).
+    // XXX too big
     TypedString(TypedString),
     /// Scalar function call e.g. `LEFT(foo, 5)`
-    Function(Function),
+    // XXX too big
+    Function(Box<Function>),
     /// `CASE [<operand>] WHEN <condition> THEN <result> ... [ELSE <result>] END`
     ///
     /// Note we only recognize a complete single expression as `<condition>`,
     /// not `< 0` nor `1, 2, 3` as allowed in a `<simple when clause>` per
     /// <https://jakewheat.github.io/sql-overview/sql-2011-foundation-grammar.html#simple-when-clause>
+    // XXX too big
     Case {
         /// The attached `CASE` token (keeps original spacing/comments).
         case_token: AttachedToken,
@@ -1266,6 +1271,7 @@ pub enum Expr {
     /// An array expression e.g. `ARRAY[1, 2]`
     Array(Array),
     /// An interval expression e.g. `INTERVAL '1' YEAR`
+    // XXX too big
     Interval(Interval),
     /// `MySQL` specific text search function [(1)].
     ///
@@ -1317,6 +1323,7 @@ pub enum Expr {
     /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/functions#higher-order-functions---operator-and-lambdaparams-expr-function)
     /// [Databricks](https://docs.databricks.com/en/sql/language-manual/sql-ref-lambda-functions.html)
     /// [DuckDB](https://duckdb.org/docs/stable/sql/functions/lambda)
+    // XXX too big
     Lambda(LambdaFunction),
     /// Checks membership of a value in a JSON array
     MemberOf(MemberOf),
@@ -1327,6 +1334,16 @@ impl Expr {
     pub fn value(value: impl Into<ValueWithSpan>) -> Self {
         Expr::Value(value.into())
     }
+
+    /// Convenience method to retrieve `Expr::Function`'s value if `self` is a
+    /// function expression.
+    pub fn as_function(&self) -> Option<&Function> {
+        if let Expr::Function(f) = self {
+            Some(&**f)
+        } else {
+            None
+        }
+    }
 }
 
 /// The contents inside the `[` and `]` in a subscript expression.
@@ -10741,7 +10758,7 @@ pub enum TableObject {
     /// INSERT INTO TABLE FUNCTION remote('localhost', default.simple_table)
     /// ```
     /// [Clickhouse](https://clickhouse.com/docs/en/sql-reference/table-functions)
-    TableFunction(Function),
+    TableFunction(Box<Function>),
 }
 
 impl fmt::Display for TableObject {

src/parser/mod.rs

@@ -1516,7 +1516,7 @@ impl<'a> Parser<'a> {
                         filter: None,
                         over: None,
                         within_group: vec![],
-                    })))
+                    }.into())))
                 }
             Keyword::CURRENT_TIMESTAMP
             | Keyword::CURRENT_TIME
@@ -1578,7 +1578,7 @@ impl<'a> Parser<'a> {
                         null_treatment: None,
                         over: None,
                         within_group: vec![],
-                    })))
+                    }.into())))
                 }
             Keyword::NOT => Ok(Some(self.parse_not()?)),
             Keyword::MATCH if self.dialect.supports_match_against() => {
@@ -2404,7 +2404,7 @@ impl<'a> Parser<'a> {
         self.parse_function_call(name).map(Expr::Function)
     }
 
-    fn parse_function_call(&mut self, name: ObjectName) -> Result<Function, ParserError> {
+    fn parse_function_call(&mut self, name: ObjectName) -> Result<Box<Function>, ParserError> {
         self.expect_token(&Token::LParen)?;
 
         // Snowflake permits a subquery to be passed as an argument without
@@ -2421,7 +2421,7 @@ impl<'a> Parser<'a> {
                 null_treatment: None,
                 over: None,
                 within_group: vec![],
-            });
+            }.into());
         }
 
         let mut args = self.parse_function_argument_list()?;
@@ -2489,7 +2489,7 @@ impl<'a> Parser<'a> {
             filter,
             over,
             within_group,
-        })
+        }.into())
     }
 
     /// Optionally parses a null treatment clause.
@@ -2524,7 +2524,7 @@ impl<'a> Parser<'a> {
             over: None,
             null_treatment: None,
             within_group: vec![],
-        }))
+        }.into()))
     }
 
     /// Parse window frame `UNITS` clause: `ROWS`, `RANGE`, or `GROUPS`.
@@ -11036,7 +11036,7 @@ impl<'a> Parser<'a> {
         let object_name = self.parse_object_name(false)?;
         if self.peek_token_ref().token == Token::LParen {
             match self.parse_function(object_name)? {
-                Expr::Function(f) => Ok(Statement::Call(f)),
+                Expr::Function(f) => Ok(Statement::Call(*f)),
                 other => parser_err!(
                     format!("Expected a simple procedure call but found: {other}"),
                     self.peek_token_ref().span.start
@@ -13780,7 +13780,7 @@ impl<'a> Parser<'a> {
                     let function_expr = self.parse_function(function_name)?;
                     if let Expr::Function(function) = function_expr {
                         let alias = self.parse_identifier_optional_alias()?;
-                        pipe_operators.push(PipeOperator::Call { function, alias });
+                        pipe_operators.push(PipeOperator::Call { function: *function, alias });
                     } else {
                         return Err(ParserError::ParserError(
                             "Expected function call after CALL".to_string(),

src/test_utils.rs

@@ -451,7 +451,7 @@ pub fn call(function: &str, args: impl IntoIterator<Item = Expr>) -> Expr {
         null_treatment: None,
         over: None,
         within_group: vec![],
-    })
+    }.into())
 }
 
 /// Gets the first index column (mysql calls it a key part) of the first index found in a

tests/sqlparser_bigquery.rs

@@ -2237,7 +2237,7 @@ fn parse_map_access_expr() {
                     over: None,
                     within_group: vec![],
                     uses_odbc_syntax: false,
-                }),
+                }.into()),
             }),
             AccessExpr::Dot(Expr::Identifier(Ident::with_span(
                 Span::new(Location::of(1, 24), Location::of(1, 25)),

tests/sqlparser_clickhouse.rs

@@ -191,7 +191,7 @@ fn parse_delimited_identifiers() {
         expr_from_projection(&select.projection[0]),
     );
     assert_eq!(
-        &Expr::Function(Function {
+        Some(&Function {
             name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
             uses_odbc_syntax: false,
             parameters: FunctionArguments::None,
@@ -205,7 +205,7 @@ fn parse_delimited_identifiers() {
             over: None,
             within_group: vec![],
         }),
-        expr_from_projection(&select.projection[1]),
+        expr_from_projection(&select.projection[1]).as_function(),
     );
     match &select.projection[2] {
         SelectItem::ExprWithAlias { expr, alias } => {
@@ -826,7 +826,7 @@ fn parse_create_table_with_variant_default_expressions() {
                         data_type: DataType::Datetime(None),
                         options: vec![ColumnOptionDef {
                             name: None,
-                            option: ColumnOption::Materialized(Expr::Function(Function {
+                            option: ColumnOption::Materialized(Expr::Function(Box::new(Function {
                                 name: ObjectName::from(vec![Ident::new("now")]),
                                 uses_odbc_syntax: false,
                                 args: FunctionArguments::List(FunctionArgumentList {
@@ -839,15 +839,15 @@ fn parse_create_table_with_variant_default_expressions() {
                                 filter: None,
                                 over: None,
                                 within_group: vec![],
-                            }))
+                            })))
                         }],
                     },
                     ColumnDef {
                         name: Ident::new("b"),
                         data_type: DataType::Datetime(None),
                         options: vec![ColumnOptionDef {
                             name: None,
-                            option: ColumnOption::Ephemeral(Some(Expr::Function(Function {
+                            option: ColumnOption::Ephemeral(Some(Expr::Function(Box::new(Function {
                                 name: ObjectName::from(vec![Ident::new("now")]),
                                 uses_odbc_syntax: false,
                                 args: FunctionArguments::List(FunctionArgumentList {
@@ -860,7 +860,7 @@ fn parse_create_table_with_variant_default_expressions() {
                                 filter: None,
                                 over: None,
                                 within_group: vec![],
-                            })))
+                            }))))
                         }],
                     },
                     ColumnDef {
@@ -876,7 +876,7 @@ fn parse_create_table_with_variant_default_expressions() {
                         data_type: DataType::String(None),
                         options: vec![ColumnOptionDef {
                             name: None,
-                            option: ColumnOption::Alias(Expr::Function(Function {
+                            option: ColumnOption::Alias(Expr::Function(Box::new(Function {
                                 name: ObjectName::from(vec![Ident::new("toString")]),
                                 uses_odbc_syntax: false,
                                 args: FunctionArguments::List(FunctionArgumentList {
@@ -891,7 +891,7 @@ fn parse_create_table_with_variant_default_expressions() {
                                 filter: None,
                                 over: None,
                                 within_group: vec![],
-                            }))
+                            })))
                         }],
                     }
                 ]