refactor BEGIN TRANSACTION statements in SQLite

Author: Takahiro Ebato

src/ast/mod.rs

@@ -1819,7 +1819,7 @@ pub enum Statement {
     StartTransaction {
         modes: Vec<TransactionMode>,
         begin: bool,
-        // Only for sqlite
+        /// Only for SQLite
         modifier: Option<TransactionModifier>,
     },
     /// `SET TRANSACTION ...`

src/dialect/generic.rs

@@ -38,4 +38,8 @@ impl Dialect for GenericDialect {
     fn supports_group_by_expr(&self) -> bool {
         true
     }
+
+    fn supports_start_transaction_modifier(&self) -> bool {
+        true
+    }
 }

src/dialect/mod.rs

@@ -128,6 +128,10 @@ pub trait Dialect: Debug + Any {
     fn supports_in_empty_list(&self) -> bool {
         false
     }
+    /// Returns true if the dialect supports `BEGIN {DEFERRED | IMMEDIATE | EXCLUSIVE} [TRANSACTION]` statements
+    fn supports_start_transaction_modifier(&self) -> bool {
+        false
+    }
     /// Returns true if the dialect has a CONVERT function which accepts a type first
     /// and an expression second, e.g. `CONVERT(varchar, 1)`
     fn convert_type_before_value(&self) -> bool {

src/dialect/sqlite.rs

@@ -40,6 +40,10 @@ impl Dialect for SQLiteDialect {
         true
     }
 
+    fn supports_start_transaction_modifier(&self) -> bool {
+        true
+    }
+
     fn is_identifier_part(&self, ch: char) -> bool {
         self.is_identifier_start(ch) || ch.is_ascii_digit()
     }

src/parser/mod.rs

@@ -7839,7 +7839,7 @@ impl<'a> Parser<'a> {
     }
 
     pub fn parse_begin(&mut self) -> Result<Statement, ParserError> {
-        let modifier = if !dialect_of!(self is SQLiteDialect) {
+        let modifier = if !self.dialect.supports_start_transaction_modifier() {
             None
         } else if self.parse_keyword(Keyword::DEFERRED) {
             Some(TransactionModifier::Deferred)

tests/sqlparser_common.rs

@@ -6232,40 +6232,6 @@ fn parse_start_transaction() {
     );
 }
 
-#[test]
-fn parse_start_transaction_sqlite() {
-    let dialect = SQLiteDialect {};
-
-    let check = |sql: &str, expected_modifier: Option<TransactionModifier>| match Parser::parse_sql(
-        &dialect, &sql,
-    )
-    .unwrap()
-    .pop()
-    .unwrap()
-    {
-        Statement::StartTransaction { modifier, .. } => assert_eq!(modifier, expected_modifier),
-        _ => panic!("{}", sql),
-    };
-
-    let sql = "BEGIN DEFERRED";
-    check(sql, Some(TransactionModifier::Deferred));
-
-    let sql = "BEGIN DEFERRED TRANSACTION";
-    check(sql, Some(TransactionModifier::Deferred));
-
-    let sql = "BEGIN IMMEDIATE";
-    check(sql, Some(TransactionModifier::Immediate));
-
-    let sql = "BEGIN IMMEDIATE TRANSACTION";
-    check(sql, Some(TransactionModifier::Immediate));
-
-    let sql = "BEGIN EXCLUSIVE";
-    check(sql, Some(TransactionModifier::Exclusive));
-
-    let sql = "BEGIN EXCLUSIVE TRANSACTION";
-    check(sql, Some(TransactionModifier::Exclusive));
-}
-
 #[test]
 fn parse_set_transaction() {
     // SET TRANSACTION shares transaction mode parsing code with START

tests/sqlparser_sqlite.rs

@@ -431,6 +431,16 @@ fn invalid_empty_list() {
     );
 }
 
+#[test]
+fn parse_start_transaction_with_modifier() {
+    sqlite_and_generic().verified_stmt("BEGIN DEFERRED TRANSACTION");
+    sqlite_and_generic().verified_stmt("BEGIN IMMEDIATE TRANSACTION");
+    sqlite_and_generic().verified_stmt("BEGIN EXCLUSIVE TRANSACTION");
+    sqlite_and_generic().one_statement_parses_to("BEGIN DEFERRED", "BEGIN DEFERRED TRANSACTION");
+    sqlite_and_generic().one_statement_parses_to("BEGIN IMMEDIATE", "BEGIN IMMEDIATE TRANSACTION");
+    sqlite_and_generic().one_statement_parses_to("BEGIN EXCLUSIVE", "BEGIN EXCLUSIVE TRANSACTION");
+}
+
 fn sqlite() -> TestedDialects {
     TestedDialects {
         dialects: vec![Box::new(SQLiteDialect {})],