Add SQLite transaction modes

Author: raffomania

src/database/connection.rs

@@ -1,8 +1,10 @@
+use std::{future::Future, pin::Pin};
+
+use futures_util::Stream;
+
 use crate::{
     DbBackend, DbErr, ExecResult, QueryResult, Statement, StatementBuilder, TransactionError,
 };
-use futures_util::Stream;
-use std::{future::Future, pin::Pin};
 
 /// The generic API for a database connection that can perform query or execute statements.
 /// It abstracts database connection and transaction
@@ -125,6 +127,45 @@ impl std::fmt::Display for AccessMode {
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+/// Which kind of transaction to start. Only supported by SQLite.
+/// <https://www.sqlite.org/lang_transaction.html>
+#[cfg(feature = "sqlx-sqlite")]
+pub enum SqliteTransactionMode {
+    /// The default. Transaction starts when the next statement is executed, and
+    /// will be a read or write transaction depending on that statement.
+    Deferred,
+    /// Start a write transaction as soon as the BEGIN statement is received.
+    Immediate,
+    /// Start a write transaction as soon as the BEGIN statement is received.
+    /// When in non-WAL mode, also block all other transactions from reading the
+    /// database.
+    Exclusive,
+}
+
+#[cfg(feature = "sqlx-sqlite")]
+impl SqliteTransactionMode {
+    /// The keyword used to start a transaction in this mode (the word coming after "BEGIN").
+    pub fn sqlite_keyword(&self) -> &'static str {
+        match self {
+            SqliteTransactionMode::Deferred => "DEFERRED",
+            SqliteTransactionMode::Immediate => "IMMEDIATE",
+            SqliteTransactionMode::Exclusive => "EXCLUSIVE",
+        }
+    }
+}
+
+/// Configuration for starting a transaction
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
+pub struct TransactionConfig {
+    #[cfg(any(feature = "sqlx-postgres", feature = "sqlx-mysql"))]
+    pub isolation_level: Option<IsolationLevel>,
+    #[cfg(any(feature = "sqlx-postgres", feature = "sqlx-mysql"))]
+    pub access_mode: Option<AccessMode>,
+    #[cfg(feature = "sqlx-sqlite")]
+    pub sqlite_transaction_mode: Option<SqliteTransactionMode>,
+}
+
 /// Spawn database transaction
 #[async_trait::async_trait]
 pub trait TransactionTrait {

src/database/transaction.rs

@@ -1,16 +1,20 @@
 #![allow(unused_assignments)]
+use std::{future::Future, pin::Pin, sync::Arc};
+
+use futures_util::lock::Mutex;
+#[cfg(feature = "sqlx-dep")]
+use sqlx::TransactionManager;
+use tracing::instrument;
+
+#[cfg(feature = "sqlx-sqlite")]
+use crate::SqliteTransactionMode;
 use crate::{
     AccessMode, ConnectionTrait, DbBackend, DbErr, ExecResult, InnerConnection, IsolationLevel,
-    QueryResult, Statement, StreamTrait, TransactionSession, TransactionStream, TransactionTrait,
-    debug_print, error::*,
+    QueryResult, SqliteTransactionMode, Statement, StreamTrait, TransactionSession,
+    TransactionStream, TransactionTrait, debug_print, error::*,
 };
 #[cfg(feature = "sqlx-dep")]
 use crate::{sqlx_error_to_exec_err, sqlx_error_to_query_err};
-use futures_util::lock::Mutex;
-#[cfg(feature = "sqlx-dep")]
-use sqlx::TransactionManager;
-use std::{future::Future, pin::Pin, sync::Arc};
-use tracing::instrument;
 
 /// Defines a database transaction, whether it is an open transaction and the type of
 /// backend to use.
@@ -92,9 +96,20 @@ impl DatabaseTransaction {
                             access_mode,
                         )
                         .await?;
-                        <sqlx::Sqlite as sqlx::Database>::TransactionManager::begin(c, None)
-                            .await
-                            .map_err(sqlx_error_to_query_err)
+                        // TODO using this for beginning a nested transaction currently causes an error. Should we make it a warning instead?
+                        let statement = match config.sqlite_transaction_mode {
+                            Some(mode) => Some(std::borrow::Cow::from(format!(
+                                "BEGIN {}",
+                                mode.sqlite_keyword()
+                            ))),
+                            None => None,
+                        };
+                        <sqlx::Sqlite as sqlx::Database>::TransactionManager::begin(
+                            c,
+                            statement.into(),
+                        )
+                        .await
+                        .map_err(sqlx_error_to_query_err)
                     }
                     #[cfg(feature = "rusqlite")]
                     InnerConnection::Rusqlite(c) => c.begin(),