Skip to content

Commit a5acca5

Browse files
raffomaniaraffomania
committed
change begin_with_config calls
1 parent d9431f1 commit a5acca5

File tree

12 files changed

+144
-207
lines changed

12 files changed

+144
-207
lines changed

‎src/database/connection.rs‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -178,8 +178,7 @@ pub trait TransactionTrait {
178178
/// Returns a Transaction that can be committed or rolled back
179179
async fn begin_with_config(
180180
&self,
181-
isolation_level: Option<IsolationLevel>,
182-
access_mode: Option<AccessMode>,
181+
config: TransactionConfig,
183182
) -> Result<Self::Transaction, DbErr>;
184183

185184
/// Execute the function inside a transaction.
@@ -198,8 +197,7 @@ pub trait TransactionTrait {
198197
async fn transaction_with_config<F, T, E>(
199198
&self,
200199
callback: F,
201-
isolation_level: Option<IsolationLevel>,
202-
access_mode: Option<AccessMode>,
200+
config: TransactionConfig,
203201
) -> Result<T, TransactionError<E>>
204202
where
205203
F: for<'c> FnOnce(

‎src/database/db_connection.rs‎

Lines changed: 37 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
use crate::{
2-
AccessMode, ConnectionTrait, DatabaseTransaction, ExecResult, IsolationLevel, QueryResult,
3-
Schema, SchemaBuilder, Statement, StatementBuilder, StreamTrait, TransactionError,
2+
ConnectionTrait, DatabaseTransaction, ExecResult, QueryResult, Schema, SchemaBuilder,
3+
Statement, StatementBuilder, StreamTrait, TransactionConfig, TransactionError,
44
TransactionTrait, error::*,
55
};
66
use std::{fmt::Debug, future::Future, pin::Pin};
@@ -351,15 +351,21 @@ impl TransactionTrait for DatabaseConnection {
351351
async fn begin(&self) -> Result<DatabaseTransaction, DbErr> {
352352
match &self.inner {
353353
#[cfg(feature = "sqlx-mysql")]
354-
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.begin(None, None).await,
354+
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
355+
conn.begin(TransactionConfig::default()).await
356+
}
355357
#[cfg(feature = "sqlx-postgres")]
356358
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
357-
conn.begin(None, None).await
359+
conn.begin(TransactionConfig::default()).await
358360
}
359361
#[cfg(feature = "sqlx-sqlite")]
360-
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.begin(None, None).await,
362+
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
363+
conn.begin(TransactionConfig::default()).await
364+
}
361365
#[cfg(feature = "rusqlite")]
362-
DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.begin(None, None),
366+
DatabaseConnectionType::RusqliteSharedConnection(conn) => {
367+
conn.begin(TransactionConfig::default())
368+
}
363369
#[cfg(feature = "mock")]
364370
DatabaseConnectionType::MockDatabaseConnection(conn) => {
365371
DatabaseTransaction::new_mock(Arc::clone(conn), None).await
@@ -375,26 +381,17 @@ impl TransactionTrait for DatabaseConnection {
375381
#[instrument(level = "trace")]
376382
async fn begin_with_config(
377383
&self,
378-
_isolation_level: Option<IsolationLevel>,
379-
_access_mode: Option<AccessMode>,
384+
_config: TransactionConfig,
380385
) -> Result<DatabaseTransaction, DbErr> {
381386
match &self.inner {
382387
#[cfg(feature = "sqlx-mysql")]
383-
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
384-
conn.begin(_isolation_level, _access_mode).await
385-
}
388+
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.begin(_config).await,
386389
#[cfg(feature = "sqlx-postgres")]
387-
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
388-
conn.begin(_isolation_level, _access_mode).await
389-
}
390+
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => conn.begin(_config).await,
390391
#[cfg(feature = "sqlx-sqlite")]
391-
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
392-
conn.begin(_isolation_level, _access_mode).await
393-
}
392+
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.begin(_config).await,
394393
#[cfg(feature = "rusqlite")]
395-
DatabaseConnectionType::RusqliteSharedConnection(conn) => {
396-
conn.begin(_isolation_level, _access_mode)
397-
}
394+
DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.begin(_config),
398395
#[cfg(feature = "mock")]
399396
DatabaseConnectionType::MockDatabaseConnection(conn) => {
400397
DatabaseTransaction::new_mock(Arc::clone(conn), None).await
@@ -408,7 +405,8 @@ impl TransactionTrait for DatabaseConnection {
408405
}
409406

410407
/// Execute the function inside a transaction.
411-
/// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
408+
/// If the function returns an error, the transaction will be rolled back.
409+
/// If it does not return an error, the transaction will be committed.
412410
#[instrument(level = "trace", skip(_callback))]
413411
async fn transaction<F, T, E>(&self, _callback: F) -> Result<T, TransactionError<E>>
414412
where
@@ -422,19 +420,22 @@ impl TransactionTrait for DatabaseConnection {
422420
match &self.inner {
423421
#[cfg(feature = "sqlx-mysql")]
424422
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
425-
conn.transaction(_callback, None, None).await
423+
conn.transaction(_callback, TransactionConfig::default())
424+
.await
426425
}
427426
#[cfg(feature = "sqlx-postgres")]
428427
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
429-
conn.transaction(_callback, None, None).await
428+
conn.transaction(_callback, TransactionConfig::default())
429+
.await
430430
}
431431
#[cfg(feature = "sqlx-sqlite")]
432432
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
433-
conn.transaction(_callback, None, None).await
433+
conn.transaction(_callback, TransactionConfig::default())
434+
.await
434435
}
435436
#[cfg(feature = "rusqlite")]
436437
DatabaseConnectionType::RusqliteSharedConnection(conn) => {
437-
conn.transaction(_callback, None, None)
438+
conn.transaction(_callback, TransactionConfig::default())
438439
}
439440
#[cfg(feature = "mock")]
440441
DatabaseConnectionType::MockDatabaseConnection(conn) => {
@@ -455,13 +456,13 @@ impl TransactionTrait for DatabaseConnection {
455456
}
456457

457458
/// Execute the function inside a transaction.
458-
/// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
459+
/// If the function returns an error, the transaction will be rolled back.
460+
/// If it does not return an error, the transaction will be committed.
459461
#[instrument(level = "trace", skip(_callback))]
460462
async fn transaction_with_config<F, T, E>(
461463
&self,
462464
_callback: F,
463-
_isolation_level: Option<IsolationLevel>,
464-
_access_mode: Option<AccessMode>,
465+
_config: TransactionConfig,
465466
) -> Result<T, TransactionError<E>>
466467
where
467468
F: for<'c> FnOnce(
@@ -474,22 +475,19 @@ impl TransactionTrait for DatabaseConnection {
474475
match &self.inner {
475476
#[cfg(feature = "sqlx-mysql")]
476477
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
477-
conn.transaction(_callback, _isolation_level, _access_mode)
478-
.await
478+
conn.transaction(_callback, _config).await
479479
}
480480
#[cfg(feature = "sqlx-postgres")]
481481
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
482-
conn.transaction(_callback, _isolation_level, _access_mode)
483-
.await
482+
conn.transaction(_callback, _config).await
484483
}
485484
#[cfg(feature = "sqlx-sqlite")]
486485
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
487-
conn.transaction(_callback, _isolation_level, _access_mode)
488-
.await
486+
conn.transaction(_callback, _config).await
489487
}
490488
#[cfg(feature = "rusqlite")]
491489
DatabaseConnectionType::RusqliteSharedConnection(conn) => {
492-
conn.transaction(_callback, _isolation_level, _access_mode)
490+
conn.transaction(_callback, _config)
493491
}
494492
#[cfg(feature = "mock")]
495493
DatabaseConnectionType::MockDatabaseConnection(conn) => {
@@ -556,8 +554,8 @@ impl DatabaseConnection {
556554

557555
#[cfg(feature = "rbac")]
558556
impl DatabaseConnection {
559-
/// Load RBAC data from the same database as this connection and setup RBAC engine.
560-
/// If the RBAC engine already exists, it will be replaced.
557+
/// Load RBAC data from the same database as this connection and setup RBAC
558+
/// engine. If the RBAC engine already exists, it will be replaced.
561559
pub async fn load_rbac(&self) -> Result<(), DbErr> {
562560
self.load_rbac_from(self).await
563561
}
@@ -575,7 +573,8 @@ impl DatabaseConnection {
575573
self.rbac.replace(engine);
576574
}
577575

578-
/// Create a restricted connection with access control specific for the user.
576+
/// Create a restricted connection with access control specific for the
577+
/// user.
579578
pub fn restricted_for(
580579
&self,
581580
user_id: crate::rbac::RbacUserId,

‎src/database/executor.rs‎

Lines changed: 8 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
use crate::{
2-
AccessMode, ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr,
3-
ExecResult, IsolationLevel, QueryResult, Statement, TransactionError, TransactionTrait,
2+
ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr, ExecResult,
3+
QueryResult, Statement, TransactionConfig, TransactionError, TransactionTrait,
44
};
55
use crate::{Schema, SchemaBuilder};
66
use std::future::Future;
@@ -78,16 +78,11 @@ impl TransactionTrait for DatabaseExecutor<'_> {
7878

7979
async fn begin_with_config(
8080
&self,
81-
isolation_level: Option<IsolationLevel>,
82-
access_mode: Option<AccessMode>,
81+
config: TransactionConfig,
8382
) -> Result<DatabaseTransaction, DbErr> {
8483
match self {
85-
DatabaseExecutor::Connection(conn) => {
86-
conn.begin_with_config(isolation_level, access_mode).await
87-
}
88-
DatabaseExecutor::Transaction(trans) => {
89-
trans.begin_with_config(isolation_level, access_mode).await
90-
}
84+
DatabaseExecutor::Connection(conn) => conn.begin_with_config(config).await,
85+
DatabaseExecutor::Transaction(trans) => trans.begin_with_config(config).await,
9186
}
9287
}
9388

@@ -109,8 +104,7 @@ impl TransactionTrait for DatabaseExecutor<'_> {
109104
async fn transaction_with_config<F, T, E>(
110105
&self,
111106
callback: F,
112-
isolation_level: Option<IsolationLevel>,
113-
access_mode: Option<AccessMode>,
107+
config: TransactionConfig,
114108
) -> Result<T, TransactionError<E>>
115109
where
116110
F: for<'c> FnOnce(
@@ -122,13 +116,10 @@ impl TransactionTrait for DatabaseExecutor<'_> {
122116
{
123117
match self {
124118
DatabaseExecutor::Connection(conn) => {
125-
conn.transaction_with_config(callback, isolation_level, access_mode)
126-
.await
119+
conn.transaction_with_config(callback, config).await
127120
}
128121
DatabaseExecutor::Transaction(trans) => {
129-
trans
130-
.transaction_with_config(callback, isolation_level, access_mode)
131-
.await
122+
trans.transaction_with_config(callback, config).await
132123
}
133124
}
134125
}

‎src/database/restricted_connection.rs‎

Lines changed: 17 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,17 @@
1-
use crate::rbac::{
2-
PermissionRequest, RbacEngine, RbacError, RbacPermissionsByResources,
3-
RbacResourcesAndPermissions, RbacRoleHierarchyList, RbacRolesAndRanks, RbacUserRolePermissions,
4-
ResourceRequest,
5-
entity::{role::RoleId, user::UserId},
6-
};
71
use crate::{
82
AccessMode, ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr,
93
ExecResult, IsolationLevel, QueryResult, Statement, StatementBuilder, TransactionError,
104
TransactionSession, TransactionTrait,
115
};
6+
use crate::{
7+
TransactionConfig,
8+
rbac::{
9+
PermissionRequest, RbacEngine, RbacError, RbacPermissionsByResources,
10+
RbacResourcesAndPermissions, RbacRoleHierarchyList, RbacRolesAndRanks,
11+
RbacUserRolePermissions, ResourceRequest,
12+
entity::{role::RoleId, user::UserId},
13+
},
14+
};
1215
use std::{
1316
pin::Pin,
1417
sync::{Arc, RwLock},
@@ -223,15 +226,11 @@ impl TransactionTrait for RestrictedConnection {
223226
#[instrument(level = "trace")]
224227
async fn begin_with_config(
225228
&self,
226-
isolation_level: Option<IsolationLevel>,
227-
access_mode: Option<AccessMode>,
229+
config: TransactionConfig,
228230
) -> Result<RestrictedTransaction, DbErr> {
229231
Ok(RestrictedTransaction {
230232
user_id: self.user_id,
231-
conn: self
232-
.conn
233-
.begin_with_config(isolation_level, access_mode)
234-
.await?,
233+
conn: self.conn.begin_with_config(config).await?,
235234
rbac: self.conn.rbac.clone(),
236235
})
237236
}
@@ -258,8 +257,7 @@ impl TransactionTrait for RestrictedConnection {
258257
async fn transaction_with_config<F, T, E>(
259258
&self,
260259
callback: F,
261-
isolation_level: Option<IsolationLevel>,
262-
access_mode: Option<AccessMode>,
260+
config: TransactionConfig,
263261
) -> Result<T, TransactionError<E>>
264262
where
265263
F: for<'c> FnOnce(
@@ -270,7 +268,7 @@ impl TransactionTrait for RestrictedConnection {
270268
E: std::fmt::Display + std::fmt::Debug + Send,
271269
{
272270
let transaction = self
273-
.begin_with_config(isolation_level, access_mode)
271+
.begin_with_config(config)
274272
.await
275273
.map_err(TransactionError::Connection)?;
276274
transaction.run(callback).await
@@ -293,15 +291,11 @@ impl TransactionTrait for RestrictedTransaction {
293291
#[instrument(level = "trace")]
294292
async fn begin_with_config(
295293
&self,
296-
isolation_level: Option<IsolationLevel>,
297-
access_mode: Option<AccessMode>,
294+
config: TransactionConfig,
298295
) -> Result<RestrictedTransaction, DbErr> {
299296
Ok(RestrictedTransaction {
300297
user_id: self.user_id,
301-
conn: self
302-
.conn
303-
.begin_with_config(isolation_level, access_mode)
304-
.await?,
298+
conn: self.conn.begin_with_config(config).await?,
305299
rbac: self.rbac.clone(),
306300
})
307301
}
@@ -328,8 +322,7 @@ impl TransactionTrait for RestrictedTransaction {
328322
async fn transaction_with_config<F, T, E>(
329323
&self,
330324
callback: F,
331-
isolation_level: Option<IsolationLevel>,
332-
access_mode: Option<AccessMode>,
325+
config: TransactionConfig,
333326
) -> Result<T, TransactionError<E>>
334327
where
335328
F: for<'c> FnOnce(
@@ -340,7 +333,7 @@ impl TransactionTrait for RestrictedTransaction {
340333
E: std::fmt::Display + std::fmt::Debug + Send,
341334
{
342335
let transaction = self
343-
.begin_with_config(isolation_level, access_mode)
336+
.begin_with_config(config)
344337
.await
345338
.map_err(TransactionError::Connection)?;
346339
transaction.run(callback).await

0 commit comments

Comments
 (0)