Parse the DEFERRABLE transaction mode

Author: LucaCappelletti94

src/ast/mod.rs

@@ -9231,12 +9231,14 @@ impl fmt::Display for AttachDuckDBDatabaseOption {
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-/// Mode for transactions: access mode or isolation level.
+/// Mode for transactions: access mode, isolation level or deferrability.
 pub enum TransactionMode {
     /// Access mode for a transaction (e.g. `READ ONLY` / `READ WRITE`).
     AccessMode(TransactionAccessMode),
     /// Isolation level for a transaction (e.g. `SERIALIZABLE`).
     IsolationLevel(TransactionIsolationLevel),
+    /// `DEFERRABLE` when true, `NOT DEFERRABLE` when false.
+    Deferrable(bool),
 }
 
 impl fmt::Display for TransactionMode {
@@ -9245,6 +9247,11 @@ impl fmt::Display for TransactionMode {
         match self {
             AccessMode(access_mode) => write!(f, "{access_mode}"),
             IsolationLevel(iso_level) => write!(f, "ISOLATION LEVEL {iso_level}"),
+            Deferrable(deferrable) => f.write_str(if *deferrable {
+                "DEFERRABLE"
+            } else {
+                "NOT DEFERRABLE"
+            }),
         }
     }
 }

src/parser/mod.rs

@@ -19905,6 +19905,11 @@ impl<'a> Parser<'a> {
                 TransactionMode::AccessMode(TransactionAccessMode::ReadOnly)
             } else if self.parse_keywords(&[Keyword::READ, Keyword::WRITE]) {
                 TransactionMode::AccessMode(TransactionAccessMode::ReadWrite)
+            } else if self.parse_keyword(Keyword::DEFERRABLE) {
+                TransactionMode::Deferrable(true)
+            } else if self.parse_keyword(Keyword::NOT) {
+                self.expect_keyword_is(Keyword::DEFERRABLE)?;
+                TransactionMode::Deferrable(false)
             } else if required {
                 self.expected_ref("transaction mode", self.peek_token_ref())?
             } else {

tests/sqlparser_common.rs

@@ -20015,3 +20015,86 @@ fn parse_function_arg_call_chain_no_exponential_blowup() {
     rx.recv_timeout(Duration::from_secs(5))
         .expect("parser should reject this quickly, not loop exponentially");
 }
+
+#[test]
+fn parse_transaction_deferrable_mode() {
+    // The third transaction mode of the SQL standard, spelled the same in
+    // PostgreSQL: <https://www.postgresql.org/docs/current/sql-set-transaction.html>
+    let dialects = all_dialects_except(|d|
+        // BigQuery and Snowflake do not support this syntax
+        d.is::<BigQueryDialect>() || d.is::<SnowflakeDialect>());
+
+    match dialects.verified_stmt("START TRANSACTION DEFERRABLE") {
+        Statement::StartTransaction { modes, .. } => {
+            assert_eq!(modes, vec![TransactionMode::Deferrable(true)])
+        }
+        _ => unreachable!(),
+    }
+
+    dialects.verified_stmt("BEGIN TRANSACTION NOT DEFERRABLE");
+
+    // PostgreSQL's `BEGIN` needs no transaction keyword; MsSql reads a bare
+    // `BEGIN` followed by anything else as the start of a `BEGIN ... END` block.
+    all_dialects_except(|d| {
+        d.is::<BigQueryDialect>() || d.is::<SnowflakeDialect>() || d.is::<MsSqlDialect>()
+    })
+    .verified_stmt("BEGIN DEFERRABLE");
+
+    match dialects
+        .verified_stmt("START TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY, DEFERRABLE")
+    {
+        Statement::StartTransaction { modes, .. } => assert_eq!(
+            modes,
+            vec![
+                TransactionMode::IsolationLevel(TransactionIsolationLevel::Serializable),
+                TransactionMode::AccessMode(TransactionAccessMode::ReadOnly),
+                TransactionMode::Deferrable(true),
+            ]
+        ),
+        _ => unreachable!(),
+    }
+
+    // As with the other modes, PostgreSQL allows the commas to be omitted.
+    match dialects.one_statement_parses_to(
+        "START TRANSACTION NOT DEFERRABLE READ WRITE",
+        "START TRANSACTION NOT DEFERRABLE, READ WRITE",
+    ) {
+        Statement::StartTransaction { modes, .. } => assert_eq!(
+            modes,
+            vec![
+                TransactionMode::Deferrable(false),
+                TransactionMode::AccessMode(TransactionAccessMode::ReadWrite),
+            ]
+        ),
+        _ => unreachable!(),
+    }
+
+    match verified_stmt("SET TRANSACTION DEFERRABLE") {
+        Statement::Set(Set::SetTransaction { modes, .. }) => {
+            assert_eq!(modes, vec![TransactionMode::Deferrable(true)])
+        }
+        _ => unreachable!(),
+    }
+
+    match verified_stmt("SET SESSION CHARACTERISTICS AS TRANSACTION NOT DEFERRABLE") {
+        Statement::Set(Set::SetTransaction { modes, session, .. }) => {
+            assert_eq!(modes, vec![TransactionMode::Deferrable(false)]);
+            assert!(session);
+        }
+        _ => unreachable!(),
+    }
+
+    assert_eq!(
+        ParserError::ParserError("Expected: DEFERRABLE, found: SERIALIZABLE".to_string()),
+        dialects
+            .parse_sql_statements("START TRANSACTION NOT SERIALIZABLE")
+            .unwrap_err()
+    );
+
+    assert_eq!(
+        ParserError::ParserError("Expected: transaction mode, found: EOF".to_string()),
+        dialects
+            .parse_sql_statements("START TRANSACTION DEFERRABLE,")
+            .unwrap_err()
+    );
+}