Drop ExceptionClause, fix Display

Author: bombsimon

src/ast/mod.rs

@@ -2982,44 +2982,6 @@ impl From<Set> for Statement {
     }
 }
 
-/// An exception representing exception handling with the `EXCEPTION` keyword.
-///
-/// Snowflake: <https://docs.snowflake.com/en/sql-reference/snowflake-scripting/exception>
-/// BigQuery: <https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#beginexceptionend>
-#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct ExceptionClause {
-    /// When represents each `WHEN` case
-    pub when: Vec<ExceptionWhen>,
-    /// The exception that is being raised or the current exception being handled if `None`.
-    ///
-    /// Example
-    /// RAISE;
-    /// RAISE MY_EXCEPTION;
-    /// RAISE USING MESSAGE = "Some error";
-    ///
-    /// BigQuery: <https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#raise>
-    /// Snowflake: <https://docs.snowflake.com/en/sql-reference/snowflake-scripting/raise>
-    // pub raises: Option<Option<Ident>>,
-    pub raises: Option<Box<Statement>>,
-}
-
-impl Display for ExceptionClause {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, " EXCEPTION")?;
-        for w in &self.when {
-            write!(f, "{w}")?;
-        }
-
-        if let Some(raises) = &self.raises {
-            write!(f, " {raises};")?;
-        }
-
-        Ok(())
-    }
-}
-
 /// A representation of a `WHEN` arm with all the identifiers catched and the statements to execute
 /// for the arm.
 ///
@@ -3037,7 +2999,7 @@ impl Display for ExceptionWhen {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            " WHEN {idents} THEN",
+            "WHEN {idents} THEN",
             idents = display_separated(&self.idents, " OR ")
         )?;
 
@@ -3738,24 +3700,20 @@ pub enum Statement {
         /// END;
         /// ```
         statements: Vec<Statement>,
-        /// Exception handling with exception clauses and raises.
+        /// Exception handling with exception clauses.
         /// Example:
         /// ```sql
-        /// BEGIN
-        ///     SELECT 1;
         /// EXCEPTION
         ///     WHEN EXCEPTION_1 THEN
         ///         SELECT 2;
         ///     WHEN EXCEPTION_2 OR EXCEPTION_3 THEN
         ///         SELECT 3;
         ///     WHEN OTHER THEN
         ///         SELECT 4;
-        /// RAISE;
-        /// END;
         /// ```
         /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#beginexceptionend>
         /// <https://docs.snowflake.com/en/sql-reference/snowflake-scripting/exception>
-        exception: Option<ExceptionClause>,
+        exception: Option<Vec<ExceptionWhen>>,
         /// TRUE if the statement has an `END` keyword.
         has_end_keyword: bool,
     },
@@ -5600,7 +5558,7 @@ impl fmt::Display for Statement {
                 transaction,
                 modifier,
                 statements,
-                exception,
+                exception: exception_handling,
                 has_end_keyword,
             } => {
                 if *syntax_begin {
@@ -5622,8 +5580,11 @@ impl fmt::Display for Statement {
                     write!(f, " ")?;
                     format_statement_list(f, statements)?;
                 }
-                if let Some(exception) = exception {
-                    write!(f, "{exception}")?;
+                if let Some(exception_when) = exception_handling {
+                    write!(f, " EXCEPTION")?;
+                    for when in exception_when {
+                        write!(f, " {when}")?;
+                    }
                 }
                 if *has_end_keyword {
                     write!(f, " END")?;

src/parser/mod.rs

@@ -15136,15 +15136,11 @@ impl<'a> Parser<'a> {
     pub fn parse_begin_exception_end(&mut self) -> Result<Statement, ParserError> {
         let statements = self.parse_statement_list(&[Keyword::EXCEPTION, Keyword::END])?;
 
-        let exception = if self.parse_keyword(Keyword::EXCEPTION) {
+        let exception_handling = if self.parse_keyword(Keyword::EXCEPTION) {
             let mut when = Vec::new();
 
-            // We can have multiple `WHEN` arms so we consume all cases until `END` or an exception
-            // is `RAISE`ed.
-            while self
-                .peek_one_of_keywords(&[Keyword::END, Keyword::RAISE])
-                .is_none()
-            {
+            // We can have multiple `WHEN` arms so we consume all cases until `END`
+            while !self.peek_keyword(Keyword::END) {
                 self.expect_keyword(Keyword::WHEN)?;
 
                 // Each `WHEN` case can have one or more conditions, e.g.
@@ -15159,21 +15155,12 @@ impl<'a> Parser<'a> {
                     self.maybe_parse(|p| p.expect_keyword(Keyword::OR))?;
                 }
 
-                let statements =
-                    self.parse_statement_list(&[Keyword::WHEN, Keyword::RAISE, Keyword::END])?;
+                let statements = self.parse_statement_list(&[Keyword::WHEN, Keyword::END])?;
 
                 when.push(ExceptionWhen { idents, statements });
             }
 
-            let raises = if self.peek_keyword(Keyword::RAISE) {
-                let raises = Some(Box::new(self.parse_raise_stmt()?));
-                self.expect_token(&Token::SemiColon)?;
-                raises
-            } else {
-                None
-            };
-
-            Some(ExceptionClause { when, raises })
+            Some(when)
         } else {
             None
         };
@@ -15183,7 +15170,7 @@ impl<'a> Parser<'a> {
         Ok(Statement::StartTransaction {
             begin: true,
             statements,
-            exception,
+            exception: exception_handling,
             has_end_keyword: true,
             transaction: None,
             modifier: None,

tests/sqlparser_bigquery.rs

@@ -261,7 +261,7 @@ fn parse_at_at_identifier() {
 
 #[test]
 fn parse_begin() {
-    let sql = r#"BEGIN SELECT 1; EXCEPTION WHEN ERROR THEN SELECT 2; END"#;
+    let sql = r#"BEGIN SELECT 1; EXCEPTION WHEN ERROR THEN SELECT 2; RAISE USING MESSAGE = FORMAT('ERR: %s', 'Bad'); END"#;
     let Statement::StartTransaction {
         statements,
         exception,
@@ -275,7 +275,7 @@ fn parse_begin() {
     assert!(exception.is_some());
 
     let exception = exception.unwrap();
-    assert_eq!(1, exception.when.len());
+    assert_eq!(1, exception.len());
     assert!(has_end_keyword);
 
     bigquery().verified_stmt(

tests/sqlparser_snowflake.rs

@@ -4124,9 +4124,9 @@ END
     assert!(has_end_keyword);
 
     let exception = exception.unwrap();
-    assert_eq!(3, exception.when.len());
-    assert_eq!(1, exception.when[0].idents.len());
-    assert_eq!(1, exception.when[0].statements.len());
-    assert_eq!(2, exception.when[1].idents.len());
-    assert_eq!(2, exception.when[1].statements.len());
+    assert_eq!(3, exception.len());
+    assert_eq!(1, exception[0].idents.len());
+    assert_eq!(1, exception[0].statements.len());
+    assert_eq!(2, exception[1].idents.len());
+    assert_eq!(2, exception[1].statements.len());
 }