fixup! Add support for DuckDB's CREATE MACRO statements

Author: MartinNowak

src/ast/mod.rs

@@ -1589,21 +1589,8 @@ pub enum Statement {
         or_replace: bool,
         temporary: bool,
         name: ObjectName,
-        args: Option<Vec<OperateMacroArg>>,
-        expr: Expr,
-    },
-    /// ```sql
-    /// CREATE MACRO
-    /// ```
-    ///
-    /// Supported variants:
-    /// 1. [DuckDB](https://duckdb.org/docs/sql/statements/create_macro)
-    CreateTableMacro {
-        or_replace: bool,
-        temporary: bool,
-        name: ObjectName,
-        args: Option<Vec<OperateMacroArg>>,
-        query: Query,
+        args: Option<Vec<MacroArg>>,
+        definition: MacroDefinition,
     },
     /// ```sql
     /// CREATE STAGE
@@ -2129,7 +2116,7 @@ impl fmt::Display for Statement {
                 temporary,
                 name,
                 args,
-                expr,
+                definition,
             } => {
                 write!(
                     f,
@@ -2140,26 +2127,10 @@ impl fmt::Display for Statement {
                 if let Some(args) = args {
                     write!(f, "({})", display_comma_separated(args))?;
                 }
-                write!(f, " AS {expr}")?;
-                Ok(())
-            }
-            Statement::CreateTableMacro {
-                or_replace,
-                temporary,
-                name,
-                args,
-                query,
-            } => {
-                write!(
-                    f,
-                    "CREATE {or_replace}{temp}MACRO {name} ",
-                    temp = if *temporary { "TEMPORARY " } else { "" },
-                    or_replace = if *or_replace { "OR REPLACE " } else { "" },
-                )?;
-                if let Some(args) = args {
-                    write!(f, "({})", display_comma_separated(args))?;
+                match definition {
+                    MacroDefinition::Expr(expr) => write!(f, " AS {expr}")?,
+                    MacroDefinition::Table(query) => write!(f, " AS TABLE {query}")?,
                 }
-                write!(f, " AS TABLE {query}")?;
                 Ok(())
             }
             Statement::CreateView {
@@ -4368,19 +4339,19 @@ impl fmt::Display for CreateFunctionUsing {
     }
 }
 
-/// DuckDB specific feature.
+/// `NAME = <EXPR>` arguments for DuckDB macros
 ///
 /// See [Create Macro - DuckDB](https://duckdb.org/docs/sql/statements/create_macro)
 /// for more details
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct OperateMacroArg {
+pub struct MacroArg {
     pub name: Ident,
     pub default_expr: Option<Expr>,
 }
 
-impl OperateMacroArg {
+impl MacroArg {
     /// Returns an argument with name.
     pub fn new(name: &str) -> Self {
         Self {
@@ -4390,8 +4361,7 @@ impl OperateMacroArg {
     }
 }
 
-
-impl fmt::Display for OperateMacroArg {
+impl fmt::Display for MacroArg {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.name)?;
         if let Some(default_expr) = &self.default_expr {
@@ -4401,6 +4371,24 @@ impl fmt::Display for OperateMacroArg {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum MacroDefinition {
+    Expr(Expr),
+    Table(Query),
+}
+
+impl fmt::Display for MacroDefinition {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            MacroDefinition::Expr(expr) => write!(f, "{expr}")?,
+            MacroDefinition::Table(query) => write!(f, "{query}")?,
+        }
+        Ok(())
+    }
+}
+
 /// Schema possible naming variants ([1]).
 ///
 /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#schema-definition

src/parser.rs

@@ -2626,7 +2626,7 @@ impl<'a> Parser<'a> {
                 return_type,
                 params,
             })
-        } else if dialect_of!(self is DuckDbDialect) {
+        } else if dialect_of!(self is DuckDbDialect | GenericDialect) {
             self.parse_create_macro(or_replace, temporary)
         } else {
             self.prev_token();
@@ -2708,55 +2708,46 @@ impl<'a> Parser<'a> {
         or_replace: bool,
         temporary: bool,
     ) -> Result<Statement, ParserError> {
-        if dialect_of!(self is DuckDbDialect) {
+        if dialect_of!(self is DuckDbDialect |  GenericDialect) {
             let name = self.parse_object_name()?;
             self.expect_token(&Token::LParen)?;
             let args = if self.consume_token(&Token::RParen) {
                 self.prev_token();
                 None
             } else {
-                 Some(self.parse_comma_separated(Parser::parse_macro_arg)?)
+                Some(self.parse_comma_separated(Parser::parse_macro_arg)?)
             };
 
             self.expect_token(&Token::RParen)?;
             self.expect_keyword(Keyword::AS)?;
 
-            if self.parse_keyword(Keyword::TABLE) {
-                Ok(Statement::CreateTableMacro {
-                    or_replace,
-                    temporary,
-                    name,
-                    args,
-                    query: self.parse_query()?,
-                })
-            } else {
-                Ok(Statement::CreateMacro {
-                    or_replace,
-                    temporary,
-                    name,
-                    args,
-                    expr: self.parse_expr()?,
-                })
-            }
+            Ok(Statement::CreateMacro {
+                or_replace,
+                temporary,
+                name,
+                args,
+                definition: if self.parse_keyword(Keyword::TABLE) {
+                    MacroDefinition::Table(self.parse_query()?)
+                } else {
+                    MacroDefinition::Expr(self.parse_expr()?)
+                },
+            })
         } else {
             self.prev_token();
             self.expected("an object type after CREATE", self.peek_token())
         }
     }
 
-    fn parse_macro_arg(&mut self) -> Result<OperateMacroArg, ParserError> {
+    fn parse_macro_arg(&mut self) -> Result<MacroArg, ParserError> {
         let name = self.parse_identifier()?;
 
-        let default_expr = if self.consume_token(&Token::DuckAssignment) || self.consume_token(&Token::RArrow)
-        {
-            Some(self.parse_expr()?)
-        } else {
-            None
-        };
-        Ok(OperateMacroArg {
-            name,
-            default_expr,
-        })
+        let default_expr =
+            if self.consume_token(&Token::DuckAssignment) || self.consume_token(&Token::RArrow) {
+                Some(self.parse_expr()?)
+            } else {
+                None
+            };
+        Ok(MacroArg { name, default_expr })
     }
 
     pub fn parse_create_external_table(

tests/sqlparser_duckdb.rs

@@ -71,50 +71,61 @@ fn parse_div_infix() {
 
 #[test]
 fn test_create_macro() {
-    let _macro = duckdb().verified_stmt("CREATE MACRO schema.add(a, b) AS a + b");
+    let macro_ = duckdb().verified_stmt("CREATE MACRO schema.add(a, b) AS a + b");
     let expected = Statement::CreateMacro {
         or_replace: false,
         temporary: false,
         name: ObjectName(vec![Ident::new("schema"), Ident::new("add")]),
-        args: Some(vec![OperateMacroArg::new("a"), OperateMacroArg::new("b")]),
-        expr: Expr::BinaryOp {
+        args: Some(vec![MacroArg::new("a"), MacroArg::new("b")]),
+        definition: MacroDefinition::Expr(Expr::BinaryOp {
             left: Box::new(Expr::Identifier(Ident::new("a"))),
             op: BinaryOperator::Plus,
             right: Box::new(Expr::Identifier(Ident::new("b"))),
-        },
+        }),
     };
-    assert_eq!(expected, _macro);
+    assert_eq!(expected, macro_);
 }
 
 #[test]
 fn test_create_macro_default_args() {
-    let _macro = duckdb().verified_stmt("CREATE MACRO add_default(a, b := 5) AS a + b");
+    let macro_ = duckdb().verified_stmt("CREATE MACRO add_default(a, b := 5) AS a + b");
     let expected = Statement::CreateMacro {
         or_replace: false,
         temporary: false,
         name: ObjectName(vec![Ident::new("add_default")]),
-        args: Some(vec![OperateMacroArg::new("a"), OperateMacroArg{ name: Ident::new("b"), default_expr: Some(Expr::Value(Value::Number("5".into(), false)))}]),
-        expr: Expr::BinaryOp {
+        args: Some(vec![
+            MacroArg::new("a"),
+            MacroArg {
+                name: Ident::new("b"),
+                default_expr: Some(Expr::Value(Value::Number("5".into(), false))),
+            },
+        ]),
+        definition: MacroDefinition::Expr(Expr::BinaryOp {
             left: Box::new(Expr::Identifier(Ident::new("a"))),
             op: BinaryOperator::Plus,
             right: Box::new(Expr::Identifier(Ident::new("b"))),
-        },
+        }),
     };
-    assert_eq!(expected, _macro);
+    assert_eq!(expected, macro_);
 }
 
 #[test]
 fn test_create_table_macro() {
     let query = "SELECT col1_value AS column1, col2_value AS column2 UNION ALL SELECT 'Hello' AS col1_value, 456 AS col2_value";
-    let _macro = duckdb().verified_stmt(
-        &("CREATE OR REPLACE TEMPORARY MACRO dynamic_table (col1_value, col2_value) AS TABLE ".to_string() + query),
+    let macro_ = duckdb().verified_stmt(
+        &("CREATE OR REPLACE TEMPORARY MACRO dynamic_table(col1_value, col2_value) AS TABLE "
+            .to_string()
+            + query),
     );
-    let expected = Statement::CreateTableMacro {
+    let expected = Statement::CreateMacro {
         or_replace: true,
         temporary: true,
         name: ObjectName(vec![Ident::new("dynamic_table")]),
-        args: Some(vec![OperateMacroArg::new("col1_value"), OperateMacroArg::new("col2_value")]),
-        query: duckdb().verified_query(query),
+        args: Some(vec![
+            MacroArg::new("col1_value"),
+            MacroArg::new("col2_value"),
+        ]),
+        definition: MacroDefinition::Table(duckdb().verified_query(query)),
     };
-    assert_eq!(expected, _macro);
+    assert_eq!(expected, macro_);
 }