Add support for CREATE TRIGGER for SQL Server

- similar to functions & procedures, this dialect can define triggers with a multi statement block
- there's no `EXECUTE` keyword here, so that means the `exec_body` used by other dialects becomes an `Option`

Author: aharpervc

src/ast/mod.rs

@@ -3624,6 +3624,7 @@ pub enum Statement {
     /// ```
     ///
     /// Postgres: <https://www.postgresql.org/docs/current/sql-createtrigger.html>
+    /// SQL Server: <https://learn.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql>
     CreateTrigger {
         /// The `OR REPLACE` clause is used to re-create the trigger if it already exists.
         ///
@@ -3685,7 +3686,9 @@ pub enum Statement {
         ///  Triggering conditions
         condition: Option<Expr>,
         /// Execute logic block
-        exec_body: TriggerExecBody,
+        exec_body: Option<TriggerExecBody>,
+        /// For SQL dialects with statement(s) for a body
+        statements: Vec<Statement>,
         /// The characteristic of the trigger, which include whether the trigger is `DEFERRABLE`, `INITIALLY DEFERRED`, or `INITIALLY IMMEDIATE`,
         characteristics: Option<ConstraintCharacteristics>,
     },
@@ -4057,6 +4060,11 @@ pub enum Statement {
     /// RETURN scalar_expression
     ///
     /// See: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql
+    ///
+    /// for Triggers:
+    /// RETURN
+    ///
+    /// See: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql
     Return(ReturnStatement),
 }
 
@@ -4486,6 +4494,7 @@ impl fmt::Display for Statement {
                 condition,
                 include_each,
                 exec_body,
+                statements,
                 characteristics,
             } => {
                 write!(
@@ -4520,7 +4529,20 @@ impl fmt::Display for Statement {
                 if let Some(condition) = condition {
                     write!(f, " WHEN {condition}")?;
                 }
-                write!(f, " EXECUTE {exec_body}")
+                if let Some(exec_body) = exec_body {
+                    write!(f, " EXECUTE {exec_body}")?;
+                }
+                if !statements.is_empty() {
+                    write!(f, " AS ")?;
+                    if statements.len() > 1 {
+                        write!(f, "BEGIN ")?;
+                    }
+                    write!(f, "{}", display_separated(statements, "; "))?;
+                    if statements.len() > 1 {
+                        write!(f, " END")?;
+                    }
+                }
+                Ok(())
             }
             Statement::DropTrigger {
                 if_exists,

src/ast/trigger.rs

@@ -110,6 +110,7 @@ impl fmt::Display for TriggerEvent {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum TriggerPeriod {
+    For,
     After,
     Before,
     InsteadOf,
@@ -118,6 +119,7 @@ pub enum TriggerPeriod {
 impl fmt::Display for TriggerPeriod {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            TriggerPeriod::For => write!(f, "FOR"),
             TriggerPeriod::After => write!(f, "AFTER"),
             TriggerPeriod::Before => write!(f, "BEFORE"),
             TriggerPeriod::InsteadOf => write!(f, "INSTEAD OF"),

src/parser/mod.rs

@@ -5278,11 +5278,15 @@ impl<'a> Parser<'a> {
         or_replace: bool,
         is_constraint: bool,
     ) -> Result<Statement, ParserError> {
-        if !dialect_of!(self is PostgreSqlDialect | GenericDialect | MySqlDialect) {
+        if !dialect_of!(self is PostgreSqlDialect | GenericDialect | MySqlDialect | MsSqlDialect) {
             self.prev_token();
             return self.expected("an object type after CREATE", self.peek_token());
         }
 
+        if dialect_of!(self is MsSqlDialect) {
+            return self.parse_mssql_create_trigger(or_replace, is_constraint);
+        }
+
         let name = self.parse_object_name(false)?;
         let period = self.parse_trigger_period()?;
 
@@ -5335,18 +5339,69 @@ impl<'a> Parser<'a> {
             trigger_object,
             include_each,
             condition,
-            exec_body,
+            exec_body: Some(exec_body),
+            statements: vec![],
             characteristics,
         })
     }
 
+    /// Parse `CREATE TRIGGER` for [Mssql]
+    ///
+    /// [Mssql]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql
+    pub fn parse_mssql_create_trigger(
+        &mut self,
+        or_replace: bool,
+        is_constraint: bool,
+    ) -> Result<Statement, ParserError> {
+        let name = self.parse_object_name(false)?;
+        self.expect_keyword_is(Keyword::ON)?;
+        let table_name = self.parse_object_name(false)?;
+        let period = self.parse_trigger_period()?;
+        let events = self.parse_comma_separated(Parser::parse_trigger_event)?;
+
+        self.expect_keyword_is(Keyword::AS)?;
+
+        let statements = if self.peek_keyword(Keyword::BEGIN) {
+            self.next_token();
+            let mut result = self.parse_statements()?;
+            // note: `parse_statements` will consume the `END` token & produce a Commit statement...
+            if let Some(Statement::Commit{ chain, end, modifier }) = result.last() {
+                if *chain == false && *end == true && *modifier == None {
+                    result = result[..result.len() - 1].to_vec();
+                }
+            }
+            result
+        } else {
+            vec![self.parse_statement()?]
+        };
+
+        Ok(Statement::CreateTrigger {
+            or_replace,
+            is_constraint,
+            name,
+            period,
+            events,
+            table_name,
+            referenced_table_name: None,
+            referencing: Vec::new(),
+            trigger_object: TriggerObject::Statement,
+            include_each: false,
+            condition: None,
+            exec_body: None,
+            statements,
+            characteristics: None,
+        })
+    }
+
     pub fn parse_trigger_period(&mut self) -> Result<TriggerPeriod, ParserError> {
         Ok(
             match self.expect_one_of_keywords(&[
+                Keyword::FOR,
                 Keyword::BEFORE,
                 Keyword::AFTER,
                 Keyword::INSTEAD,
             ])? {
+                Keyword::FOR => TriggerPeriod::For,
                 Keyword::BEFORE => TriggerPeriod::Before,
                 Keyword::AFTER => TriggerPeriod::After,
                 Keyword::INSTEAD => self
@@ -15088,10 +15143,14 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_return(&mut self) -> Result<Statement, ParserError> {
-        let expr = self.parse_expr()?;
-        Ok(Statement::Return(ReturnStatement {
-            value: Some(ReturnStatementValue::Expr(expr)),
-        }))
+        match self.maybe_parse(|p| p.parse_expr())? {
+            Some(expr) => Ok(Statement::Return(ReturnStatement {
+                value: Some(ReturnStatementValue::Expr(expr)),
+            })),
+            None => Ok(Statement::Return(ReturnStatement {
+                value: None,
+            }))
+        }
     }
 
     /// Consume the parser and return its underlying token buffer

tests/sqlparser_mssql.rs

@@ -2341,3 +2341,198 @@ fn parse_mssql_merge_with_output() {
         OUTPUT $action, deleted.ProductID INTO dsi.temp_products";
     ms_and_generic().verified_stmt(stmt);
 }
+
+#[test]
+fn parse_create_trigger() {
+    let create_trigger = r#"
+        CREATE TRIGGER reminder1
+        ON Sales.Customer
+        AFTER INSERT, UPDATE
+        AS RAISERROR ('Notify Customer Relations', 16, 10);
+    "#;
+    let create_stmt = ms().one_statement_parses_to(create_trigger, "");
+    assert_eq!(
+        create_stmt,
+        Statement::CreateTrigger {
+            or_replace: false,
+            is_constraint: false,
+            name: ObjectName::from(vec![Ident::new("reminder1")]),
+            period: TriggerPeriod::After,
+            events: vec![
+                TriggerEvent::Insert,
+                TriggerEvent::Update(vec![]),
+            ],
+            table_name: ObjectName::from(vec![Ident::new("Sales"), Ident::new("Customer")]),
+            referenced_table_name: None,
+            referencing: vec![],
+            trigger_object: TriggerObject::Statement,
+            include_each: false,
+            condition: None,
+            exec_body: None,
+            statements: vec![Statement::RaisError {
+                message: Box::new(Expr::Value(
+                    (Value::SingleQuotedString("Notify Customer Relations".to_string())).with_empty_span()
+                )),
+                severity: Box::new(Expr::Value(
+                    (Value::Number("16".parse().unwrap(), false)).with_empty_span()
+                )),
+                state: Box::new(Expr::Value(
+                    (Value::Number("10".parse().unwrap(), false)).with_empty_span()
+                )),
+                arguments: vec![],
+                options: vec![],
+            }],
+            characteristics: None,
+        }
+    );
+
+    let multi_statement_trigger = r#"
+        CREATE TRIGGER some_trigger ON some_table FOR INSERT
+        AS
+        BEGIN
+            RAISERROR('Trigger fired', 10, 1);
+        END
+    "#;
+    let create_stmt = ms().one_statement_parses_to(multi_statement_trigger, "");
+    assert_eq!(
+        create_stmt,
+        Statement::CreateTrigger {
+            or_replace: false,
+            is_constraint: false,
+            name: ObjectName::from(vec![Ident::new("some_trigger")]),
+            period: TriggerPeriod::For,
+            events: vec![TriggerEvent::Insert],
+            table_name: ObjectName::from(vec![Ident::new("some_table")]),
+            referenced_table_name: None,
+            referencing: vec![],
+            trigger_object: TriggerObject::Statement,
+            include_each: false,
+            condition: None,
+            exec_body: None,
+            statements: vec![Statement::RaisError {
+                message: Box::new(Expr::Value(
+                    (Value::SingleQuotedString("Trigger fired".to_string())).with_empty_span()
+                )),
+                severity: Box::new(Expr::Value(
+                    (Value::Number("10".parse().unwrap(), false)).with_empty_span()
+                )),
+                state: Box::new(Expr::Value(
+                    (Value::Number("1".parse().unwrap(), false)).with_empty_span()
+                )),
+                arguments: vec![],
+                options: vec![],
+            }],
+            characteristics: None,
+        }
+    );
+
+    let create_trigger_with_return = r#"
+        CREATE TRIGGER some_trigger ON some_table FOR INSERT
+        AS
+        BEGIN
+            RETURN;
+        END
+    "#;
+    let create_stmt = ms().one_statement_parses_to(create_trigger_with_return, "");
+    assert_eq!(
+        create_stmt,
+        Statement::CreateTrigger {
+            or_replace: false,
+            is_constraint: false,
+            name: ObjectName::from(vec![Ident::new("some_trigger")]),
+            period: TriggerPeriod::For,
+            events: vec![TriggerEvent::Insert],
+            table_name: ObjectName::from(vec![Ident::new("some_table")]),
+            referenced_table_name: None,
+            referencing: vec![],
+            trigger_object: TriggerObject::Statement,
+            include_each: false,
+            condition: None,
+            exec_body: None,
+            statements: vec![Statement::Return(ReturnStatement {
+                value: None,
+            })],
+            characteristics: None,
+        }
+    );
+
+    let create_trigger_with_conditional = r#"
+        CREATE TRIGGER some_trigger ON some_table FOR INSERT
+        AS
+        BEGIN
+            IF 1=2
+            BEGIN
+                RAISERROR('Trigger fired', 10, 1);
+            END
+
+            RETURN;
+        END
+    "#;
+    let create_stmt = ms().one_statement_parses_to(create_trigger_with_conditional, "");
+    assert_eq!(
+        create_stmt,
+        Statement::CreateTrigger {
+            or_replace: false,
+            is_constraint: false,
+            name: ObjectName::from(vec![Ident::new("some_trigger")]),
+            period: TriggerPeriod::For,
+            events: vec![TriggerEvent::Insert],
+            table_name: ObjectName::from(vec![Ident::new("some_table")]),
+            referenced_table_name: None,
+            referencing: vec![],
+            trigger_object: TriggerObject::Statement,
+            include_each: false,
+            condition: None,
+            exec_body: None,
+            statements: vec![
+                Statement::If(IfStatement {
+                    if_block: ConditionalStatementBlock {
+                        start_token: AttachedToken(TokenWithSpan::wrap(sqlparser::tokenizer::Token::Word(sqlparser::tokenizer::Word {
+                            value: "IF".to_string(),
+                            quote_style: None,
+                            keyword: Keyword::IF
+                        }))),
+                        condition: Some(Expr::BinaryOp {
+                            left: Box::new(Expr::Value(Value::Number("1".to_string(), false).with_empty_span())),
+                            op: sqlparser::ast::BinaryOperator::Eq,
+                            right: Box::new(Expr::Value(Value::Number("2".to_string(), false).with_empty_span())),
+                        }),
+                           then_token: None,
+                           conditional_statements: ConditionalStatements::BeginEnd {
+                            begin_token: AttachedToken(TokenWithSpan::wrap(sqlparser::tokenizer::Token::Word(sqlparser::tokenizer::Word {
+                                value: "BEGIN".to_string(),
+                                quote_style: None,
+                                keyword: Keyword::BEGIN
+                            }))),
+                            statements: vec![Statement::RaisError {
+                                message: Box::new(Expr::Value(
+                                    (Value::SingleQuotedString("Trigger fired".to_string())).with_empty_span()
+                                )),
+                                severity: Box::new(Expr::Value(
+                                    (Value::Number("10".parse().unwrap(), false)).with_empty_span()
+                                )),
+                                state: Box::new(Expr::Value(
+                                    (Value::Number("1".parse().unwrap(), false)).with_empty_span()
+                                )),
+                                arguments: vec![],
+                                options: vec![],
+                            }],
+                            end_token: AttachedToken(TokenWithSpan::wrap(sqlparser::tokenizer::Token::Word(sqlparser::tokenizer::Word {
+                                value: "END".to_string(),
+                                quote_style: None,
+                                keyword: Keyword::END
+                            }))),
+                        },
+                    },
+                    elseif_blocks: vec![],
+                    else_block: None,
+                    end_token: None,
+                }),
+                Statement::Return(ReturnStatement {
+                    value: None
+                }),
+            ],
+            characteristics: None,
+        }
+    );
+}

tests/sqlparser_mysql.rs

@@ -3410,13 +3410,14 @@ fn parse_create_trigger() {
             trigger_object: TriggerObject::Row,
             include_each: true,
             condition: None,
-            exec_body: TriggerExecBody {
+            exec_body: Some(TriggerExecBody {
                 exec_type: TriggerExecBodyType::Function,
                 func_desc: FunctionDesc {
                     name: ObjectName::from(vec![Ident::new("emp_stamp")]),
                     args: None,
                 }
-            },
+            }),
+            statements: vec![],
             characteristics: None,
         }
     );