Merge pull request #22 from fmguerreiro/fix/trigger-exec-body-call-args

fix(parser): accept call-site expression args in CREATE TRIGGER EXECUTE FUNCTION

Author: fmguerreiro

Cargo.toml

@@ -18,7 +18,7 @@
 [package]
 name = "pgmold-sqlparser"
 description = "Fork of sqlparser with additional PostgreSQL features (PARTITION OF, SECURITY DEFINER/INVOKER, SET params, EXCLUDE, TEXT SEARCH, AGGREGATE, FOREIGN TABLE/FDW, PUBLICATION, SUBSCRIPTION, ALTER DOMAIN/TRIGGER/EXTENSION, CAST, CONVERSION, LANGUAGE, RULE, STATISTICS, ACCESS METHOD, EVENT TRIGGER, TRANSFORM, SECURITY LABEL, USER MAPPING, TABLESPACE)"
-version = "0.60.13"
+version = "0.60.14"
 authors = ["Filipe Guerreiro <filipe.m.guerreiro@gmail.com>"]
 homepage = "https://github.com/fmguerreiro/datafusion-sqlparser-rs"
 documentation = "https://docs.rs/pgmold-sqlparser/"

src/ast/trigger.rs

@@ -161,24 +161,32 @@ impl fmt::Display for TriggerExecBodyType {
         }
     }
 }
-/// This keyword immediately precedes the declaration of one or two relation names that provide access to the transition relations of the triggering statement
+/// The EXECUTE clause of a CREATE TRIGGER statement.
+///
+/// Holds call-site information: the function/procedure name and optional
+/// positional argument expressions (e.g. string literals passed to
+/// `tsvector_update_trigger`).  This is deliberately distinct from
+/// `FunctionDesc`, which carries CREATE-FUNCTION-style parameter
+/// *declarations* (`argname argtype DEFAULT expr`).
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct TriggerExecBody {
     /// Whether the body is a `FUNCTION` or `PROCEDURE` invocation.
     pub exec_type: TriggerExecBodyType,
-    /// Description of the function/procedure to execute.
-    pub func_desc: FunctionDesc,
+    /// The name of the function or procedure to invoke.
+    pub func_name: ObjectName,
+    /// Call-site arguments (expressions).  `None` means no parentheses were
+    /// written; `Some(vec![])` means empty parentheses `()`.
+    pub args: Option<Vec<Expr>>,
 }
 
 impl fmt::Display for TriggerExecBody {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "{exec_type} {func_desc}",
-            exec_type = self.exec_type,
-            func_desc = self.func_desc
-        )
+        write!(f, "{} {}", self.exec_type, self.func_name)?;
+        if let Some(args) = &self.args {
+            write!(f, "({})", display_comma_separated(args))?;
+        }
+        Ok(())
     }
 }

src/parser/mod.rs

@@ -6385,18 +6385,42 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse the execution body of a trigger (`FUNCTION` or `PROCEDURE`).
+    ///
+    /// Unlike CREATE FUNCTION, trigger EXECUTE clauses take call-site
+    /// expressions as arguments (e.g. string literals), not parameter
+    /// declarations.  We therefore parse the name separately and then
+    /// parse each argument as a full expression.
     pub fn parse_trigger_exec_body(&mut self) -> Result<TriggerExecBody, ParserError> {
+        let exec_type = match self
+            .expect_one_of_keywords(&[Keyword::FUNCTION, Keyword::PROCEDURE])?
+        {
+            Keyword::FUNCTION => TriggerExecBodyType::Function,
+            Keyword::PROCEDURE => TriggerExecBodyType::Procedure,
+            unexpected_keyword => {
+                return Err(ParserError::ParserError(format!(
+                    "Internal parser error: unexpected keyword `{unexpected_keyword}` in trigger exec body"
+                )))
+            }
+        };
+
+        let func_name = self.parse_object_name(false)?;
+
+        let args = if self.consume_token(&Token::LParen) {
+            if self.consume_token(&Token::RParen) {
+                Some(vec![])
+            } else {
+                let exprs = self.parse_comma_separated(Parser::parse_expr)?;
+                self.expect_token(&Token::RParen)?;
+                Some(exprs)
+            }
+        } else {
+            None
+        };
+
         Ok(TriggerExecBody {
-            exec_type: match self
-                .expect_one_of_keywords(&[Keyword::FUNCTION, Keyword::PROCEDURE])?
-            {
-                Keyword::FUNCTION => TriggerExecBodyType::Function,
-                Keyword::PROCEDURE => TriggerExecBodyType::Procedure,
-                unexpected_keyword => return Err(ParserError::ParserError(
-                    format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in trigger exec body"),
-                )),
-            },
-            func_desc: self.parse_function_desc()?,
+            exec_type,
+            func_name,
+            args,
         })
     }
 

tests/sqlparser_mysql.rs

@@ -4222,10 +4222,8 @@ fn parse_create_trigger() {
             condition: None,
             exec_body: Some(TriggerExecBody {
                 exec_type: TriggerExecBodyType::Function,
-                func_desc: FunctionDesc {
-                    name: ObjectName::from(vec![Ident::new("emp_stamp")]),
-                    args: Some(vec![]),
-                }
+                func_name: ObjectName::from(vec![Ident::new("emp_stamp")]),
+                args: Some(vec![]),
             }),
             statements_as: false,
             statements: None,

tests/sqlparser_postgres.rs

@@ -6418,10 +6418,8 @@ fn parse_create_simple_before_insert_trigger() {
         condition: None,
         exec_body: Some(TriggerExecBody {
             exec_type: TriggerExecBodyType::Function,
-            func_desc: FunctionDesc {
-                name: ObjectName::from(vec![Ident::new("check_account_insert")]),
-                args: None,
-            },
+            func_name: ObjectName::from(vec![Ident::new("check_account_insert")]),
+            args: None,
         }),
         statements_as: false,
         statements: None,
@@ -6457,10 +6455,8 @@ fn parse_create_after_update_trigger_with_condition() {
         }))),
         exec_body: Some(TriggerExecBody {
             exec_type: TriggerExecBodyType::Function,
-            func_desc: FunctionDesc {
-                name: ObjectName::from(vec![Ident::new("check_account_update")]),
-                args: None,
-            },
+            func_name: ObjectName::from(vec![Ident::new("check_account_update")]),
+            args: None,
         }),
         statements_as: false,
         statements: None,
@@ -6489,10 +6485,8 @@ fn parse_create_instead_of_delete_trigger() {
         condition: None,
         exec_body: Some(TriggerExecBody {
             exec_type: TriggerExecBodyType::Function,
-            func_desc: FunctionDesc {
-                name: ObjectName::from(vec![Ident::new("check_account_deletes")]),
-                args: None,
-            },
+            func_name: ObjectName::from(vec![Ident::new("check_account_deletes")]),
+            args: None,
         }),
         statements_as: false,
         statements: None,
@@ -6525,10 +6519,8 @@ fn parse_create_trigger_with_multiple_events_and_deferrable() {
         condition: None,
         exec_body: Some(TriggerExecBody {
             exec_type: TriggerExecBodyType::Function,
-            func_desc: FunctionDesc {
-                name: ObjectName::from(vec![Ident::new("check_account_changes")]),
-                args: None,
-            },
+            func_name: ObjectName::from(vec![Ident::new("check_account_changes")]),
+            args: None,
         }),
         statements_as: false,
         statements: None,
@@ -6572,10 +6564,80 @@ fn parse_create_trigger_with_referencing() {
         condition: None,
         exec_body: Some(TriggerExecBody {
             exec_type: TriggerExecBodyType::Function,
-            func_desc: FunctionDesc {
-                name: ObjectName::from(vec![Ident::new("check_account_referencing")]),
-                args: None,
-            },
+            func_name: ObjectName::from(vec![Ident::new("check_account_referencing")]),
+            args: None,
+        }),
+        statements_as: false,
+        statements: None,
+        characteristics: None,
+    });
+
+    assert_eq!(pg().verified_stmt(sql), expected);
+}
+
+#[test]
+fn parse_create_trigger_with_string_literal_args() {
+    // Verify that EXECUTE FUNCTION accepts call-site expression arguments
+    // (e.g. string literals), not just bare identifiers.  This matches the
+    // PostgreSQL tsvector_update_trigger calling convention used in pagila.
+    let sql = "CREATE TRIGGER film_fulltext_trigger BEFORE INSERT OR UPDATE ON public.film FOR EACH ROW EXECUTE FUNCTION tsvector_update_trigger('fulltext', 'pg_catalog.english', 'title', 'description')";
+    let expected = Statement::CreateTrigger(CreateTrigger {
+        or_alter: false,
+        temporary: false,
+        or_replace: false,
+        is_constraint: false,
+        name: ObjectName::from(vec![Ident::new("film_fulltext_trigger")]),
+        period: Some(TriggerPeriod::Before),
+        period_before_table: true,
+        events: vec![TriggerEvent::Insert, TriggerEvent::Update(vec![])],
+        table_name: ObjectName::from(vec![
+            Ident::new("public"),
+            Ident::new("film"),
+        ]),
+        referenced_table_name: None,
+        referencing: vec![],
+        trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)),
+        condition: None,
+        exec_body: Some(TriggerExecBody {
+            exec_type: TriggerExecBodyType::Function,
+            func_name: ObjectName::from(vec![Ident::new("tsvector_update_trigger")]),
+            args: Some(vec![
+                Expr::Value(Value::SingleQuotedString("fulltext".to_string()).with_empty_span()),
+                Expr::Value(Value::SingleQuotedString("pg_catalog.english".to_string()).with_empty_span()),
+                Expr::Value(Value::SingleQuotedString("title".to_string()).with_empty_span()),
+                Expr::Value(Value::SingleQuotedString("description".to_string()).with_empty_span()),
+            ]),
+        }),
+        statements_as: false,
+        statements: None,
+        characteristics: None,
+    });
+
+    assert_eq!(pg().verified_stmt(sql), expected);
+}
+
+#[test]
+fn parse_create_trigger_with_empty_args() {
+    // EXECUTE FUNCTION fn() — explicit empty parens
+    let sql = "CREATE TRIGGER trg BEFORE INSERT ON t FOR EACH ROW EXECUTE FUNCTION my_fn()";
+    let expected = Statement::CreateTrigger(CreateTrigger {
+        or_alter: false,
+        temporary: false,
+        or_replace: false,
+        is_constraint: false,
+        name: ObjectName::from(vec![Ident::new("trg")]),
+        period: Some(TriggerPeriod::Before),
+        period_before_table: true,
+        events: vec![TriggerEvent::Insert],
+        table_name: ObjectName::from(vec![Ident::new("t")]),
+        referenced_table_name: None,
+        referencing: vec![],
+        trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)),
+        condition: None,
+        exec_body: Some(TriggerExecBody {
+            exec_type: TriggerExecBodyType::Function,
+            func_name: ObjectName::from(vec![Ident::new("my_fn")]),
+            args: Some(vec![]),
         }),
         statements_as: false,
         statements: None,
@@ -6883,10 +6945,8 @@ fn parse_trigger_related_functions() {
             condition: None,
             exec_body: Some(TriggerExecBody {
                 exec_type: TriggerExecBodyType::Function,
-                func_desc: FunctionDesc {
-                    name: ObjectName::from(vec![Ident::new("emp_stamp")]),
-                    args: Some(vec![]),
-                }
+                func_name: ObjectName::from(vec![Ident::new("emp_stamp")]),
+                args: Some(vec![]),
             }),
             statements_as: false,
             statements: None,