Move parse_mssql_create_trigger into MsSqlDialect

- this requires being able to start parsing `CREATE` statements; but if it isn't a trigger, we need to rewind
- therefore, a new `set_index` method is added to manually update the parser index

Author: aharpervc

src/dialect/mssql.rs

@@ -18,6 +18,7 @@
 use crate::ast::helpers::attached_token::AttachedToken;
 use crate::ast::{
     BeginEndStatements, ConditionalStatementBlock, ConditionalStatements, IfStatement, Statement,
+    TriggerObject,
 };
 use crate::dialect::Dialect;
 use crate::keywords::{self, Keyword};
@@ -125,6 +126,8 @@ impl Dialect for MsSqlDialect {
     fn parse_statement(&self, parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
         if parser.peek_keyword(Keyword::IF) {
             Some(self.parse_if_stmt(parser))
+        } else if parser.peek_keyword(Keyword::CREATE) {
+            self.parse_create(parser)
         } else {
             None
         }
@@ -215,6 +218,78 @@ impl MsSqlDialect {
         }))
     }
 
+    /// Parse a SQL CREATE statement
+    fn parse_create(&self, parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
+        let original_index = parser.index();
+
+        if !parser.parse_keyword(Keyword::CREATE) {
+            parser.set_index(original_index);
+            return None;
+        }
+
+        let or_alter = parser.parse_keywords(&[Keyword::OR, Keyword::ALTER]);
+
+        if parser.parse_keyword(Keyword::TRIGGER) {
+            return Some(self.parse_create_trigger(parser, or_alter));
+        }
+
+        parser.set_index(original_index);
+        None
+    }
+
+    /// Parse `CREATE TRIGGER` for [MsSql]
+    ///
+    /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql
+    fn parse_create_trigger(
+        &self,
+        parser: &mut Parser,
+        or_alter: bool,
+    ) -> Result<Statement, ParserError> {
+        let name = parser.parse_object_name(false)?;
+        parser.expect_keyword_is(Keyword::ON)?;
+        let table_name = parser.parse_object_name(false)?;
+        let period = parser.parse_trigger_period()?;
+        let events = parser.parse_comma_separated(Parser::parse_trigger_event)?;
+
+        parser.expect_keyword_is(Keyword::AS)?;
+
+        let trigger_statements_body = if parser.peek_keyword(Keyword::BEGIN) {
+            let begin_token = parser.expect_keyword(Keyword::BEGIN)?;
+            let statements = parser.parse_statement_list(&[Keyword::END])?;
+            let end_token = parser.expect_keyword(Keyword::END)?;
+
+            BeginEndStatements {
+                begin_token: AttachedToken(begin_token),
+                statements,
+                end_token: AttachedToken(end_token),
+            }
+        } else {
+            BeginEndStatements {
+                begin_token: AttachedToken::empty(),
+                statements: vec![parser.parse_statement()?],
+                end_token: AttachedToken::empty(),
+            }
+        };
+
+        Ok(Statement::CreateTrigger {
+            or_alter,
+            or_replace: false,
+            is_constraint: false,
+            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,
+        })
+    }
+
     /// Parse a sequence of statements, optionally separated by semicolon.
     ///
     /// Stops parsing when reaching EOF or the given keyword.

src/parser/mod.rs

@@ -5265,10 +5265,6 @@ impl<'a> Parser<'a> {
             return self.expected("an object type after CREATE", self.peek_token());
         }
 
-        if dialect_of!(self is MsSqlDialect) {
-            return self.parse_mssql_create_trigger(or_alter, or_replace, is_constraint);
-        }
-
         let name = self.parse_object_name(false)?;
         let period = self.parse_trigger_period()?;
 
@@ -5328,60 +5324,6 @@ impl<'a> Parser<'a> {
         })
     }
 
-    /// 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_alter: bool,
-        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_alter,
-            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(&[
@@ -15139,6 +15081,11 @@ impl<'a> Parser<'a> {
         self.index
     }
 
+    /// Manually change the parser index.
+    pub(crate) fn set_index(&mut self, index: usize) {
+        self.index = index;
+    }
+
     pub fn parse_named_window(&mut self) -> Result<NamedWindowDefinition, ParserError> {
         let ident = self.parse_identifier()?;
         self.expect_keyword_is(Keyword::AS)?;