Rusqlite: support SQLite transaction mode

Author: tyt2y3

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

@@ -329,7 +329,7 @@ impl TransactionTrait for DatabaseConnection {
             #[cfg(feature = "sqlx-postgres")]
             DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => conn.begin(None, None),
             #[cfg(feature = "sqlx-sqlite")]
-            DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.begin(None, None),
+            DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.begin(None, None, None),
             #[cfg(feature = "rusqlite")]
             DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.begin(None, None, None),
             #[cfg(feature = "mock")]
@@ -361,7 +361,7 @@ impl TransactionTrait for DatabaseConnection {
             }
             #[cfg(feature = "sqlx-sqlite")]
             DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
-                conn.begin(_isolation_level, _access_mode)
+                conn.begin(_isolation_level, _access_mode, None)
             }
             #[cfg(feature = "rusqlite")]
             DatabaseConnectionType::RusqliteSharedConnection(conn) => {

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

@@ -1,13 +1,16 @@
-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,
-    TransactionOptions, TransactionSession, TransactionTrait,
+    TransactionSession, TransactionTrait,
+};
+use crate::{
+    TransactionOptions,
+    rbac::{
+        PermissionRequest, RbacEngine, RbacError, RbacPermissionsByResources,
+        RbacResourcesAndPermissions, RbacRoleHierarchyList, RbacRolesAndRanks,
+        RbacUserRolePermissions, ResourceRequest,
+        entity::{role::RoleId, user::UserId},
+    },
 };
 use std::{
     pin::Pin,

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

@@ -1,17 +1,18 @@
 #![allow(unused_assignments)]
-use crate::SqliteTransactionMode;
+use std::sync::Arc;
+
+#[cfg(feature = "sqlx-dep")]
+use sqlx::TransactionManager;
+use std::sync::Mutex;
+use tracing::instrument;
+
 use crate::{
     AccessMode, ConnectionTrait, DbBackend, DbErr, ExecResult, InnerConnection, IsolationLevel,
-    QueryResult, Statement, StreamTrait, TransactionOptions, TransactionSession, TransactionStream,
-    TransactionTrait, debug_print, error::*,
+    QueryResult, SqliteTransactionMode, Statement, StreamTrait, TransactionOptions,
+    TransactionSession, TransactionStream, TransactionTrait, debug_print, error::*,
 };
 #[cfg(feature = "sqlx-dep")]
 use crate::{sqlx_error_to_exec_err, sqlx_error_to_query_err};
-#[cfg(feature = "sqlx-dep")]
-use sqlx::TransactionManager;
-use std::sync::Arc;
-use std::sync::Mutex;
-use tracing::instrument;
 
 /// Defines a database transaction, whether it is an open transaction and the type of
 /// backend to use.
@@ -83,22 +84,25 @@ impl DatabaseTransaction {
                     }
                     #[cfg(feature = "sqlx-sqlite")]
                     InnerConnection::Sqlite(c) => {
-                        // in SQLite isolation level and access mode are global settings
                         crate::driver::sqlx_sqlite::set_transaction_config(
                             c,
                             isolation_level,
                             access_mode,
                         )?;
-                        // TODO using this for beginning a nested transaction currently causes an error. Should we make it a warning instead?
-                        let statement = sqlite_transaction_mode.map(|mode| {
-                            std::borrow::Cow::from(format!("BEGIN {}", mode.sqlite_keyword()))
-                        });
+                        let depth = <sqlx::Sqlite as sqlx::Database>::TransactionManager::get_transaction_depth(c);
+                        let statement = if depth == 0 {
+                            sqlite_transaction_mode.map(|mode| {
+                                std::borrow::Cow::from(format!("BEGIN {}", mode.sqlite_keyword()))
+                            })
+                        } else {
+                            // Nested transaction uses SAVEPOINT; the mode only applies to the top-level BEGIN
+                            None
+                        };
                         <sqlx::Sqlite as sqlx::Database>::TransactionManager::begin(c, statement)
-                            .await
                             .map_err(sqlx_error_to_query_err)
                     }
                     #[cfg(feature = "rusqlite")]
-                    InnerConnection::Rusqlite(c) => c.begin(),
+                    InnerConnection::Rusqlite(c) => c.begin(sqlite_transaction_mode),
                     #[cfg(feature = "mock")]
                     InnerConnection::Mock(c) => {
                         c.begin();
@@ -605,19 +609,15 @@ impl TransactionTrait for DatabaseTransaction {
     #[instrument(level = "trace")]
     fn begin_with_options(
         &self,
-        TransactionOptions {
-            isolation_level,
-            access_mode,
-            sqlite_transaction_mode,
-        }: TransactionOptions,
+        options: TransactionOptions,
     ) -> Result<DatabaseTransaction, DbErr> {
         DatabaseTransaction::begin(
             Arc::clone(&self.conn),
             self.backend,
             self.metric_callback.clone(),
-            isolation_level,
-            access_mode,
-            sqlite_transaction_mode,
+            options.isolation_level,
+            options.access_mode,
+            options.sqlite_transaction_mode,
         )
     }
 

sea-orm-sync/src/driver/proxy.rs

@@ -151,6 +151,7 @@ impl crate::DatabaseTransaction {
             metric_callback,
             None,
             None,
+            None,
         )
     }
 }

sea-orm-sync/src/driver/rusqlite.rs

@@ -557,9 +557,17 @@ impl RusqliteInnerConnection {
     }
 
     #[instrument(level = "trace")]
-    pub(crate) fn begin(&mut self) -> Result<(), DbErr> {
+    pub(crate) fn begin(
+        &mut self,
+        sqlite_transaction_mode: Option<SqliteTransactionMode>,
+    ) -> Result<(), DbErr> {
         if self.transaction_depth == 0 {
-            self.execute_unprepared("BEGIN")?;
+            match sqlite_transaction_mode {
+                Some(mode) => {
+                    self.execute_unprepared(&format!("BEGIN {}", mode.sqlite_keyword()))?
+                }
+                None => self.execute_unprepared("BEGIN")?,
+            };
         } else {
             self.execute_unprepared(&format!("SAVEPOINT sp{}", self.transaction_depth))?;
         }

sea-orm-sync/src/driver/sqlx_mysql.rs

@@ -343,6 +343,7 @@ impl crate::DatabaseTransaction {
             metric_callback,
             isolation_level,
             access_mode,
+            None,
         )
     }
 }

sea-orm-sync/src/driver/sqlx_postgres.rs

@@ -374,6 +374,7 @@ impl crate::DatabaseTransaction {
             metric_callback,
             isolation_level,
             access_mode,
+            None,
         )
     }
 }

sea-orm-sync/src/driver/sqlx_sqlite.rs

@@ -14,8 +14,8 @@ use tracing::{instrument, warn};
 
 use crate::{
     AccessMode, ConnectOptions, DatabaseConnection, DatabaseConnectionType, DatabaseTransaction,
-    IsolationLevel, QueryStream, Statement, TransactionError, debug_print, error::*, executor::*,
-    sqlx_error_to_exec_err,
+    IsolationLevel, QueryStream, SqliteTransactionMode, Statement, TransactionError, debug_print,
+    error::*, executor::*, sqlx_error_to_exec_err,
 };
 
 use super::sqlx_common::*;
@@ -214,13 +214,15 @@ impl SqlxSqlitePoolConnection {
         &self,
         isolation_level: Option<IsolationLevel>,
         access_mode: Option<AccessMode>,
+        sqlite_transaction_mode: Option<SqliteTransactionMode>,
     ) -> Result<DatabaseTransaction, DbErr> {
         let conn = self.pool.acquire().map_err(sqlx_conn_acquire_err)?;
         DatabaseTransaction::new_sqlite(
             conn,
             self.metric_callback.clone(),
             isolation_level,
             access_mode,
+            sqlite_transaction_mode,
         )
     }
 
@@ -242,6 +244,7 @@ impl SqlxSqlitePoolConnection {
             self.metric_callback.clone(),
             isolation_level,
             access_mode,
+            None,
         )
         .map_err(|e| TransactionError::Connection(e))?;
         transaction.run(callback)
@@ -354,13 +357,15 @@ impl crate::DatabaseTransaction {
         metric_callback: Option<crate::metric::Callback>,
         isolation_level: Option<IsolationLevel>,
         access_mode: Option<AccessMode>,
+        sqlite_transaction_mode: Option<SqliteTransactionMode>,
     ) -> Result<crate::DatabaseTransaction, DbErr> {
         Self::begin(
             Arc::new(Mutex::new(crate::InnerConnection::Sqlite(inner))),
             crate::DbBackend::Sqlite,
             metric_callback,
             isolation_level,
             access_mode,
+            sqlite_transaction_mode,
         )
     }
 }

sea-orm-sync/tests/transaction_tests.rs

@@ -4,7 +4,10 @@ pub mod common;
 
 pub use common::{TestContext, bakery_chain::*, setup::*};
 use pretty_assertions::assert_eq;
-use sea_orm::{AccessMode, DatabaseTransaction, IsolationLevel, Set, TransactionTrait, prelude::*};
+use sea_orm::{
+    AccessMode, DatabaseTransaction, IsolationLevel, Set, SqliteTransactionMode,
+    TransactionOptions, TransactionTrait, prelude::*,
+};
 
 #[cfg(not(feature = "sync"))]
 type FutureResult<'a> =
@@ -944,3 +947,35 @@ fn _transaction_with_config<'a>(
         Ok(())
     })
 }
+
+#[sea_orm_macros::test]
+pub fn transaction_begin_with_options() -> Result<(), DbErr> {
+    let ctx = TestContext::new("transaction_begin_with_options_test");
+    create_tables(&ctx.db)?;
+
+    assert_eq!(bakery::Entity::find().all(&ctx.db)?.len(), 0);
+
+    {
+        // Transaction begin in this scope
+        let txn = ctx.db.begin_with_options(TransactionOptions {
+            sqlite_transaction_mode: Some(SqliteTransactionMode::Immediate),
+            ..Default::default()
+        })?;
+
+        seaside_bakery().save(&txn)?;
+
+        assert_eq!(bakery::Entity::find().all(&txn)?.len(), 1);
+
+        top_bakery().save(&txn)?;
+
+        assert_eq!(bakery::Entity::find().all(&txn)?.len(), 2);
+
+        // Commit changes before the end of scope
+        txn.commit()?;
+    }
+
+    assert_eq!(bakery::Entity::find().all(&ctx.db)?.len(), 2);
+
+    ctx.delete();
+    Ok(())
+}

src/database/transaction.rs

@@ -88,23 +88,27 @@ impl DatabaseTransaction {
                     }
                     #[cfg(feature = "sqlx-sqlite")]
                     InnerConnection::Sqlite(c) => {
-                        // in SQLite isolation level and access mode are global settings
                         crate::driver::sqlx_sqlite::set_transaction_config(
                             c,
                             isolation_level,
                             access_mode,
                         )
                         .await?;
-                        // TODO using this for beginning a nested transaction currently causes an error. Should we make it a warning instead?
-                        let statement = sqlite_transaction_mode.map(|mode| {
-                            std::borrow::Cow::from(format!("BEGIN {}", mode.sqlite_keyword()))
-                        });
+                        let depth = <sqlx::Sqlite as sqlx::Database>::TransactionManager::get_transaction_depth(c);
+                        let statement = if depth == 0 {
+                            sqlite_transaction_mode.map(|mode| {
+                                std::borrow::Cow::from(format!("BEGIN {}", mode.sqlite_keyword()))
+                            })
+                        } else {
+                            // Nested transaction uses SAVEPOINT; the mode only applies to the top-level BEGIN
+                            None
+                        };
                         <sqlx::Sqlite as sqlx::Database>::TransactionManager::begin(c, statement)
                             .await
                             .map_err(sqlx_error_to_query_err)
                     }
                     #[cfg(feature = "rusqlite")]
-                    InnerConnection::Rusqlite(c) => c.begin(),
+                    InnerConnection::Rusqlite(c) => c.begin(sqlite_transaction_mode),
                     #[cfg(feature = "mock")]
                     InnerConnection::Mock(c) => {
                         c.begin();