Wrap Throw in named ThrowStatement struct

Signed-off-by: Guan-Ming (Wesley) Chiu <105915352+guan404ming@users.noreply.github.com>

Author: guan404ming

src/ast/mod.rs

@@ -2816,6 +2816,41 @@ impl fmt::Display for RaiseStatementValue {
     }
 }
 
+/// A MSSQL `THROW` statement.
+///
+/// ```sql
+/// THROW [ error_number, message, state ]
+/// ```
+///
+/// [MSSQL](https://learn.microsoft.com/en-us/sql/t-sql/language-elements/throw-transact-sql)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ThrowStatement {
+    /// Error number expression.
+    pub error_number: Option<Box<Expr>>,
+    /// Error message expression.
+    pub message: Option<Box<Expr>>,
+    /// State expression.
+    pub state: Option<Box<Expr>>,
+}
+
+impl fmt::Display for ThrowStatement {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ThrowStatement {
+            error_number,
+            message,
+            state,
+        } = self;
+
+        write!(f, "THROW")?;
+        if let (Some(error_number), Some(message), Some(state)) = (error_number, message, state) {
+            write!(f, " {error_number}, {message}, {state}")?;
+        }
+        Ok(())
+    }
+}
+
 /// Represents an expression assignment within a variable `DECLARE` statement.
 ///
 /// Examples:
@@ -4676,19 +4711,8 @@ pub enum Statement {
         /// Additional `WITH` options for RAISERROR.
         options: Vec<RaisErrorOption>,
     },
-    /// Throw (MSSQL)
-    /// ```sql
-    /// THROW [ error_number, message, state ]
-    /// ```
-    /// See <https://learn.microsoft.com/en-us/sql/t-sql/language-elements/throw-transact-sql>
-    Throw {
-        /// Error number expression.
-        error_number: Option<Box<Expr>>,
-        /// Error message expression.
-        message: Option<Box<Expr>>,
-        /// State expression.
-        state: Option<Box<Expr>>,
-    },
+    /// A MSSQL `THROW` statement.
+    Throw(ThrowStatement),
     /// ```sql
     /// PRINT msg_str | @local_variable | string_expr
     /// ```
@@ -6133,19 +6157,7 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
-            Statement::Throw {
-                error_number,
-                message,
-                state,
-            } => {
-                write!(f, "THROW")?;
-                if let (Some(error_number), Some(message), Some(state)) =
-                    (error_number, message, state)
-                {
-                    write!(f, " {error_number}, {message}, {state}")?;
-                }
-                Ok(())
-            }
+            Statement::Throw(s) => write!(f, "{s}"),
             Statement::Print(s) => write!(f, "{s}"),
             Statement::Return(r) => write!(f, "{r}"),
             Statement::List(command) => write!(f, "LIST {command}"),
@@ -11676,6 +11688,12 @@ impl From<RaiseStatement> for Statement {
     }
 }
 
+impl From<ThrowStatement> for Statement {
+    fn from(t: ThrowStatement) -> Self {
+        Self::Throw(t)
+    }
+}
+
 impl From<Function> for Statement {
     fn from(f: Function) -> Self {
         Self::Call(f)

src/ast/spans.rs

@@ -481,7 +481,7 @@ impl Spanned for Statement {
             Statement::UNLISTEN { .. } => Span::empty(),
             Statement::RenameTable { .. } => Span::empty(),
             Statement::RaisError { .. } => Span::empty(),
-            Statement::Throw { .. } => Span::empty(),
+            Statement::Throw(_) => Span::empty(),
             Statement::Print { .. } => Span::empty(),
             Statement::Return { .. } => Span::empty(),
             Statement::List(..) | Statement::Remove(..) => Span::empty(),

src/parser/mod.rs

@@ -670,7 +670,10 @@ impl<'a> Parser<'a> {
                 Keyword::RELEASE => self.parse_release(),
                 Keyword::COMMIT => self.parse_commit(),
                 Keyword::RAISERROR => Ok(self.parse_raiserror()?),
-                Keyword::THROW => Ok(self.parse_throw()?),
+                Keyword::THROW => {
+                    self.prev_token();
+                    self.parse_throw().map(Into::into)
+                }
                 Keyword::ROLLBACK => self.parse_rollback(),
                 Keyword::ASSERT => self.parse_assert(),
                 // `PREPARE`, `EXECUTE` and `DEALLOCATE` are Postgres-specific
@@ -18261,28 +18264,27 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Parse a MSSQL `THROW` statement
-    /// See <https://learn.microsoft.com/en-us/sql/t-sql/language-elements/throw-transact-sql>
-    pub fn parse_throw(&mut self) -> Result<Statement, ParserError> {
-        // THROW with no arguments is a re-throw inside a CATCH block
-        if self.peek_token_ref().token == Token::SemiColon
-            || self.peek_token_ref().token == Token::EOF
-        {
-            return Ok(Statement::Throw {
-                error_number: None,
-                message: None,
-                state: None,
-            });
-        }
-        let error_number = Box::new(self.parse_expr()?);
-        self.expect_token(&Token::Comma)?;
-        let message = Box::new(self.parse_expr()?);
-        self.expect_token(&Token::Comma)?;
-        let state = Box::new(self.parse_expr()?);
-        Ok(Statement::Throw {
-            error_number: Some(error_number),
-            message: Some(message),
-            state: Some(state),
+    /// Parse a MSSQL `THROW` statement.
+    ///
+    /// See [Statement::Throw]
+    pub fn parse_throw(&mut self) -> Result<ThrowStatement, ParserError> {
+        self.expect_keyword_is(Keyword::THROW)?;
+
+        let error_number = self.maybe_parse(|p| p.parse_expr().map(Box::new))?;
+        let (message, state) = if error_number.is_some() {
+            self.expect_token(&Token::Comma)?;
+            let message = Box::new(self.parse_expr()?);
+            self.expect_token(&Token::Comma)?;
+            let state = Box::new(self.parse_expr()?);
+            (Some(message), Some(state))
+        } else {
+            (None, None)
+        };
+
+        Ok(ThrowStatement {
+            error_number,
+            message,
+            state,
         })
     }
 

tests/sqlparser_mssql.rs

@@ -1672,7 +1672,7 @@ fn test_parse_throw() {
     let s = ms().verified_stmt(sql);
     assert_eq!(
         s,
-        Statement::Throw {
+        Statement::Throw(ThrowStatement {
             error_number: Some(Box::new(Expr::Value(
                 (Value::Number("51000".parse().unwrap(), false)).with_empty_span()
             ))),
@@ -1682,7 +1682,7 @@ fn test_parse_throw() {
             state: Some(Box::new(Expr::Value(
                 (Value::Number("1".parse().unwrap(), false)).with_empty_span()
             ))),
-        }
+        })
     );
 
     // THROW with variable references
@@ -1694,11 +1694,11 @@ fn test_parse_throw() {
     let s = ms().verified_stmt(sql);
     assert_eq!(
         s,
-        Statement::Throw {
+        Statement::Throw(ThrowStatement {
             error_number: None,
             message: None,
             state: None,
-        }
+        })
     );
 }