Add SQLite transaction modes

Author: raffomania

sea-orm-sync/src/database/executor.rs

@@ -89,6 +89,16 @@ impl TransactionTrait for DatabaseExecutor<'_> {
         }
     }
 
+    fn begin_with_options(
+        &self,
+        options: TransactionOptions,
+    ) -> Result<DatabaseTransaction, DbErr> {
+        match self {
+            DatabaseExecutor::Connection(conn) => conn.begin_with_options(options),
+            DatabaseExecutor::Transaction(trans) => trans.begin_with_options(options),
+        }
+    }
+
     fn transaction<F, T, E>(&self, callback: F) -> Result<T, TransactionError<E>>
     where
         F: for<'c> FnOnce(&'c DatabaseTransaction) -> Result<T, E>,

sea-orm-sync/src/database/restricted_connection.rs

@@ -230,6 +230,18 @@ impl TransactionTrait for RestrictedConnection {
         })
     }
 
+    #[instrument(level = "trace")]
+    fn begin_with_options(
+        &self,
+        options: TransactionOptions,
+    ) -> Result<RestrictedTransaction, DbErr> {
+        Ok(RestrictedTransaction {
+            user_id: self.user_id,
+            conn: self.conn.begin_with_options(options)?,
+            rbac: self.conn.rbac.clone(),
+        })
+    }
+
     /// Execute the function inside a transaction.
     /// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
     #[instrument(level = "trace", skip(callback))]
@@ -287,6 +299,18 @@ impl TransactionTrait for RestrictedTransaction {
         })
     }
 
+    #[instrument(level = "trace")]
+    fn begin_with_options(
+        &self,
+        options: TransactionOptions,
+    ) -> Result<RestrictedTransaction, DbErr> {
+        Ok(RestrictedTransaction {
+            user_id: self.user_id,
+            conn: self.conn.begin_with_options(options)?,
+            rbac: self.conn.rbac.clone(),
+        })
+    }
+
     /// Execute the function inside a transaction.
     /// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
     #[instrument(level = "trace", skip(callback))]

sea-orm-sync/src/database/transaction.rs

@@ -593,6 +593,25 @@ impl TransactionTrait for DatabaseTransaction {
         )
     }
 
+    #[instrument(level = "trace")]
+    fn begin_with_options(
+        &self,
+        TransactionOptions {
+            isolation_level,
+            access_mode,
+            sqlite_transaction_mode,
+        }: TransactionOptions,
+    ) -> Result<DatabaseTransaction, DbErr> {
+        DatabaseTransaction::begin(
+            Arc::clone(&self.conn),
+            self.backend,
+            self.metric_callback.clone(),
+            isolation_level,
+            access_mode,
+            sqlite_transaction_mode,
+        )
+    }
+
     /// Execute the function inside a transaction.
     /// If the function returns an error, the transaction will be rolled back.
     /// Otherwise, the transaction will be committed.

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,43 @@ 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>
+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,
+}
+
+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 TransactionOptions {
+    /// Isolation level for the new transaction
+    pub isolation_level: Option<IsolationLevel>,
+    /// Access mode for the new transaction
+    pub access_mode: Option<AccessMode>,
+    /// Transaction mode (deferred, immediate, exclusive) for the new transaction. Supported only by SQLite.
+    pub sqlite_transaction_mode: Option<SqliteTransactionMode>,
+}
+
 /// Spawn database transaction
 #[async_trait::async_trait]
 pub trait TransactionTrait {
@@ -137,12 +176,20 @@ pub trait TransactionTrait {
 
     /// Execute SQL `BEGIN` transaction with isolation level and/or access mode.
     /// Returns a Transaction that can be committed or rolled back
+    /// Deprecated: use begin_with_options instead.
     async fn begin_with_config(
         &self,
         isolation_level: Option<IsolationLevel>,
         access_mode: Option<AccessMode>,
     ) -> Result<Self::Transaction, DbErr>;
 
+    /// Execute SQL `BEGIN` transaction with isolation level and/or access mode.
+    /// Returns a Transaction that can be committed or rolled back
+    async fn begin_with_options(
+        &self,
+        options: TransactionOptions,
+    ) -> Result<Self::Transaction, DbErr>;
+
     /// Execute the function inside a transaction.
     /// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
     async fn transaction<F, T, E>(&self, callback: F) -> Result<T, TransactionError<E>>

src/database/db_connection.rs

@@ -1,7 +1,7 @@
 use crate::{
     AccessMode, ConnectionTrait, DatabaseTransaction, ExecResult, IsolationLevel, QueryResult,
     Schema, SchemaBuilder, Statement, StatementBuilder, StreamTrait, TransactionError,
-    TransactionTrait, error::*,
+    TransactionOptions, TransactionTrait, error::*,
 };
 use std::{fmt::Debug, future::Future, pin::Pin};
 use tracing::instrument;
@@ -357,9 +357,11 @@ impl TransactionTrait for DatabaseConnection {
                 conn.begin(None, None).await
             }
             #[cfg(feature = "sqlx-sqlite")]
-            DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.begin(None, None).await,
+            DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
+                conn.begin(None, None, None).await
+            }
             #[cfg(feature = "rusqlite")]
-            DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.begin(None, None),
+            DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.begin(None, None, None),
             #[cfg(feature = "mock")]
             DatabaseConnectionType::MockDatabaseConnection(conn) => {
                 DatabaseTransaction::new_mock(Arc::clone(conn), None).await
@@ -389,11 +391,50 @@ impl TransactionTrait for DatabaseConnection {
             }
             #[cfg(feature = "sqlx-sqlite")]
             DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
+                conn.begin(_isolation_level, _access_mode, None).await
+            }
+            #[cfg(feature = "rusqlite")]
+            DatabaseConnectionType::RusqliteSharedConnection(conn) => {
+                conn.begin(_isolation_level, _access_mode, None)
+            }
+            #[cfg(feature = "mock")]
+            DatabaseConnectionType::MockDatabaseConnection(conn) => {
+                DatabaseTransaction::new_mock(Arc::clone(conn), None).await
+            }
+            #[cfg(feature = "proxy")]
+            DatabaseConnectionType::ProxyDatabaseConnection(conn) => {
+                DatabaseTransaction::new_proxy(conn.clone(), None).await
+            }
+            DatabaseConnectionType::Disconnected => Err(conn_err("Disconnected")),
+        }
+    }
+
+    #[instrument(level = "trace")]
+    async fn begin_with_options(
+        &self,
+        TransactionOptions {
+            isolation_level: _isolation_level,
+            access_mode: _access_mode,
+            sqlite_transaction_mode: _sqlite_transaction_mode,
+        }: TransactionOptions,
+    ) -> Result<DatabaseTransaction, DbErr> {
+        match &self.inner {
+            #[cfg(feature = "sqlx-mysql")]
+            DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
                 conn.begin(_isolation_level, _access_mode).await
             }
+            #[cfg(feature = "sqlx-postgres")]
+            DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
+                conn.begin(_isolation_level, _access_mode).await
+            }
+            #[cfg(feature = "sqlx-sqlite")]
+            DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
+                conn.begin(_isolation_level, _access_mode, _sqlite_transaction_mode)
+                    .await
+            }
             #[cfg(feature = "rusqlite")]
             DatabaseConnectionType::RusqliteSharedConnection(conn) => {
-                conn.begin(_isolation_level, _access_mode)
+                conn.begin(_isolation_level, _access_mode, _sqlite_transaction_mode)
             }
             #[cfg(feature = "mock")]
             DatabaseConnectionType::MockDatabaseConnection(conn) => {

src/database/executor.rs

@@ -1,6 +1,7 @@
 use crate::{
     AccessMode, ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr,
-    ExecResult, IsolationLevel, QueryResult, Statement, TransactionError, TransactionTrait,
+    ExecResult, IsolationLevel, QueryResult, Statement, TransactionError, TransactionOptions,
+    TransactionTrait,
 };
 use crate::{Schema, SchemaBuilder};
 use std::future::Future;
@@ -91,6 +92,16 @@ impl TransactionTrait for DatabaseExecutor<'_> {
         }
     }
 
+    async fn begin_with_options(
+        &self,
+        options: TransactionOptions,
+    ) -> Result<DatabaseTransaction, DbErr> {
+        match self {
+            DatabaseExecutor::Connection(conn) => conn.begin_with_options(options).await,
+            DatabaseExecutor::Transaction(trans) => trans.begin_with_options(options).await,
+        }
+    }
+
     async fn transaction<F, T, E>(&self, callback: F) -> Result<T, TransactionError<E>>
     where
         F: for<'c> FnOnce(

src/database/restricted_connection.rs

@@ -1,14 +1,17 @@
-use crate::rbac::{
-    PermissionRequest, RbacEngine, RbacError, RbacPermissionsByResources,
-    RbacResourcesAndPermissions, RbacRoleHierarchyList, RbacRolesAndRanks, RbacUserRolePermissions,
-    ResourceRequest,
-    entity::{role::RoleId, user::UserId},
-};
 use crate::{
     AccessMode, ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr,
     ExecResult, IsolationLevel, QueryResult, Statement, StatementBuilder, TransactionError,
     TransactionSession, TransactionTrait,
 };
+use crate::{
+    TransactionOptions,
+    rbac::{
+        PermissionRequest, RbacEngine, RbacError, RbacPermissionsByResources,
+        RbacResourcesAndPermissions, RbacRoleHierarchyList, RbacRolesAndRanks,
+        RbacUserRolePermissions, ResourceRequest,
+        entity::{role::RoleId, user::UserId},
+    },
+};
 use std::{
     pin::Pin,
     sync::{Arc, RwLock},
@@ -236,6 +239,18 @@ impl TransactionTrait for RestrictedConnection {
         })
     }
 
+    #[instrument(level = "trace")]
+    async fn begin_with_options(
+        &self,
+        options: TransactionOptions,
+    ) -> Result<RestrictedTransaction, DbErr> {
+        Ok(RestrictedTransaction {
+            user_id: self.user_id,
+            conn: self.conn.begin_with_options(options).await?,
+            rbac: self.conn.rbac.clone(),
+        })
+    }
+
     /// Execute the function inside a transaction.
     /// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
     #[instrument(level = "trace", skip(callback))]
@@ -306,6 +321,18 @@ impl TransactionTrait for RestrictedTransaction {
         })
     }
 
+    #[instrument(level = "trace")]
+    async fn begin_with_options(
+        &self,
+        options: TransactionOptions,
+    ) -> Result<RestrictedTransaction, DbErr> {
+        Ok(RestrictedTransaction {
+            user_id: self.user_id,
+            conn: self.conn.begin_with_options(options).await?,
+            rbac: self.rbac.clone(),
+        })
+    }
+
     /// Execute the function inside a transaction.
     /// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
     #[instrument(level = "trace", skip(callback))]