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`, and our `statements` is also optional for them

Author: aharpervc

src/ast/mod.rs

@@ -2344,11 +2344,16 @@ impl fmt::Display for BeginEndStatements {
             end_token: AttachedToken(end_token),
         } = self;
 
-        write!(f, "{begin_token} ")?;
+        if begin_token.token != Token::EOF {
+            write!(f, "{begin_token} ")?;
+        }
         if !statements.is_empty() {
             format_statement_list(f, statements)?;
         }
-        write!(f, " {end_token}")
+        if end_token.token != Token::EOF {
+            write!(f, " {end_token}")?;
+        }
+        Ok(())
     }
 }
 
@@ -3659,6 +3664,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.
         ///
@@ -3720,7 +3726,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: Option<BeginEndStatements>,
         /// The characteristic of the trigger, which include whether the trigger is `DEFERRABLE`, `INITIALLY DEFERRED`, or `INITIALLY IMMEDIATE`,
         characteristics: Option<ConstraintCharacteristics>,
     },
@@ -4526,19 +4534,29 @@ impl fmt::Display for Statement {
                 condition,
                 include_each,
                 exec_body,
+                statements,
                 characteristics,
             } => {
                 write!(
                     f,
-                    "CREATE {or_replace}{is_constraint}TRIGGER {name} {period}",
+                    "CREATE {or_replace}{is_constraint}TRIGGER {name} ",
                     or_replace = if *or_replace { "OR REPLACE " } else { "" },
                     is_constraint = if *is_constraint { "CONSTRAINT " } else { "" },
                 )?;
 
-                if !events.is_empty() {
-                    write!(f, " {}", display_separated(events, " OR "))?;
+                if exec_body.is_some() {
+                    write!(f, "{period}")?;
+                    if !events.is_empty() {
+                        write!(f, " {}", display_separated(events, " OR "))?;
+                    }
+                    write!(f, " ON {table_name}")?;
+                } else {
+                    write!(f, "ON {table_name}")?;
+                    write!(f, " {period}")?;
+                    if !events.is_empty() {
+                        write!(f, " {}", display_separated(events, ", "))?;
+                    }
                 }
-                write!(f, " ON {table_name}")?;
 
                 if let Some(referenced_table_name) = referenced_table_name {
                     write!(f, " FROM {referenced_table_name}")?;
@@ -4554,13 +4572,19 @@ impl fmt::Display for Statement {
 
                 if *include_each {
                     write!(f, " FOR EACH {trigger_object}")?;
-                } else {
+                } else if exec_body.is_some() {
                     write!(f, " FOR {trigger_object}")?;
                 }
                 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 let Some(statements) = statements {
+                    write!(f, " AS {statements}")?;
+                }
+                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

@@ -5259,11 +5259,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()?;
 
@@ -5316,18 +5320,73 @@ impl<'a> Parser<'a> {
             trigger_object,
             include_each,
             condition,
-            exec_body,
+            exec_body: Some(exec_body),
+            statements: None,
             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 trigger_statements_body = if self.peek_keyword(Keyword::BEGIN) {
+            let begin_token = self.expect_keyword(Keyword::BEGIN)?;
+            let statements = self.parse_statement_list(&[Keyword::END])?;
+            let end_token = self.expect_keyword(Keyword::END)?;
+
+            BeginEndStatements {
+                begin_token: AttachedToken(begin_token),
+                statements,
+                end_token: AttachedToken(end_token),
+            }
+        } else {
+            BeginEndStatements {
+                begin_token: AttachedToken::empty(),
+                statements: vec![self.parse_statement()?],
+                end_token: AttachedToken::empty(),
+            }
+        };
+
+        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: Some(trigger_statements_body),
+            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
@@ -15229,6 +15288,11 @@ impl<'a> Parser<'a> {
 
     /// Parse [Statement::Return]
     fn parse_return(&mut self) -> Result<Statement, ParserError> {
+        if let Token::Word(w) = self.peek_token().token {
+            if w.keyword == Keyword::END {
+                return Ok(Statement::Return(ReturnStatement { value: None }));
+            }
+        }
         match self.maybe_parse(|p| p.parse_expr())? {
             Some(expr) => Ok(Statement::Return(ReturnStatement {
                 value: Some(ReturnStatementValue::Expr(expr)),

tests/sqlparser_mssql.rs

@@ -271,6 +271,16 @@ fn parse_create_function() {
         END\
     ";
     let _ = ms().verified_stmt(create_or_alter_function);
+
+    let create_function_with_return_expression = "\
+        CREATE FUNCTION some_scalar_udf(@foo INT, @bar VARCHAR(256)) \
+        RETURNS INT \
+        AS \
+        BEGIN \
+            RETURN CONVERT(INT, 1) + 2; \
+        END\
+    ";
+    let _ = ms().verified_stmt(create_function_with_return_expression);
 }
 
 #[test]
@@ -2129,6 +2139,94 @@ fn parse_mssql_merge_with_output() {
     ms_and_generic().verified_stmt(stmt);
 }
 
+#[test]
+fn parse_create_trigger() {
+    let create_trigger = "\
+        CREATE TRIGGER reminder1 \
+        ON Sales.Customer \
+        AFTER INSERT, UPDATE \
+        AS RAISERROR('Notify Customer Relations', 16, 10);\
+    ";
+    let create_stmt = ms().verified_stmt(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: Some(BeginEndStatements {
+                begin_token: AttachedToken::empty(),
+                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![],
+                }],
+                end_token: AttachedToken::empty(),
+            }),
+            characteristics: None,
+        }
+    );
+
+    let multi_statement_trigger = "\
+        CREATE TRIGGER some_trigger ON some_table FOR INSERT \
+        AS \
+        BEGIN \
+            DECLARE @var INT; \
+            RAISERROR('Trigger fired', 10, 1); \
+        END\
+    ";
+    let _ = ms().verified_stmt(multi_statement_trigger);
+
+    let create_trigger_with_return = "\
+        CREATE TRIGGER some_trigger ON some_table FOR INSERT \
+        AS \
+        BEGIN \
+            RETURN; \
+        END\
+    ";
+    let _ = ms().verified_stmt(create_trigger_with_return);
+
+    let create_trigger_with_return = "\
+        CREATE TRIGGER some_trigger ON some_table FOR INSERT \
+        AS \
+        BEGIN \
+            RETURN; \
+        END\
+    ";
+    let _ = ms().verified_stmt(create_trigger_with_return);
+
+    let create_trigger_with_conditional = "\
+        CREATE TRIGGER some_trigger ON some_table FOR INSERT \
+        AS \
+        BEGIN \
+            IF 1 = 2 \
+            BEGIN \
+                RAISERROR('Trigger fired', 10, 1); \
+            END; \
+            RETURN; \
+        END\
+    ";
+    let _ = ms().verified_stmt(create_trigger_with_conditional);
+}
+
 #[test]
 fn parse_drop_trigger() {
     let sql_drop_trigger = "DROP TRIGGER emp_stamp;";

tests/sqlparser_mysql.rs

@@ -3532,13 +3532,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: None,
             characteristics: None,
         }
     );