Struct RestrictedTransaction 

pub struct RestrictedTransaction { /* private fields */ }

Available on crate feature rbac only.

Wrapper of DatabaseTransaction that performs authorization on all executed queries for the current user. Note that raw SQL Statement is not allowed currently.

Implementations

impl RestrictedTransaction

pub fn user_id(&self) -> UserId

Get the [RbacUserId] bounded to this connection.

pub async fn transaction_async<F, T, E>( &self, callback: F, ) -> Result<T, TransactionError<E>>

where F: for<'c> AsyncFnOnce(&'c RestrictedTransaction) -> Result<T, E> + Send, T: Send, E: Display + Debug + Send,

Execute the function inside a transaction. If the function returns an error, the transaction will be rolled back. Otherwise, the transaction will be committed.

pub async fn transaction_with_config_async<F, T, E>( &self, callback: F, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>, ) -> Result<T, TransactionError<E>>

where F: for<'c> AsyncFnOnce(&'c RestrictedTransaction) -> Result<T, E> + Send, T: Send, E: Display + Debug + Send,

Execute the function inside a transaction with isolation level and/or access mode. If the function returns an error, the transaction will be rolled back. Otherwise, the transaction will be committed.

pub fn user_can_run<S: StatementBuilder>(&self, stmt: &S) -> Result<(), DbErr>

Returns () if the current user can execute / query the given SQL statement. Returns DbErr::AccessDenied otherwise.

pub fn user_can<P, R>(&self, permission: P, resource: R) -> Result<bool, DbErr>

where P: Into<PermissionRequest>, R: Into<ResourceRequest>,

Returns true if the current user can perform action on resource

impl RestrictedTransaction

pub async fn commit(self) -> Result<(), DbErr>

Commit a transaction

pub async fn rollback(self) -> Result<(), DbErr>

Rolls back a transaction explicitly

Trait Implementations

impl ConnectionTrait for RestrictedTransaction

fn get_database_backend(&self) -> DbBackend

Get the database backend for the connection. This depends on feature flags enabled.

fn execute_raw<'life0, 'async_trait>( &'life0 self, stmt: Statement, ) -> Pin<Box<dyn Future<Output = Result<ExecResult, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute a Statement

fn execute<'life0, 'life1, 'async_trait, S>( &'life0 self, stmt: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<ExecResult, DbErr>> + Send + 'async_trait>>

where S: 'async_trait + StatementBuilder, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a StatementBuilder

fn execute_unprepared<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ExecResult, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a unprepared Statement

fn query_one_raw<'life0, 'async_trait>( &'life0 self, stmt: Statement, ) -> Pin<Box<dyn Future<Output = Result<Option<QueryResult>, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute a Statement and return a single row of QueryResult

fn query_one<'life0, 'life1, 'async_trait, S>( &'life0 self, stmt: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Option<QueryResult>, DbErr>> + Send + 'async_trait>>

where S: 'async_trait + StatementBuilder, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a StatementBuilder and return a single row of QueryResult

fn query_all_raw<'life0, 'async_trait>( &'life0 self, stmt: Statement, ) -> Pin<Box<dyn Future<Output = Result<Vec<QueryResult>, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute a Statement and return a vector of QueryResult

fn query_all<'life0, 'life1, 'async_trait, S>( &'life0 self, stmt: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Vec<QueryResult>, DbErr>> + Send + 'async_trait>>

where S: 'async_trait + StatementBuilder, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a StatementBuilder and return a vector of QueryResult

fn support_returning(&self) -> bool

Check if the connection supports RETURNING syntax on insert and update

fn is_mock_connection(&self) -> bool

Check if the connection is a test connection for the Mock database

impl Debug for RestrictedTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl TransactionSession for RestrictedTransaction

fn commit<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<(), DbErr>> + Send + 'async_trait>>

where Self: 'async_trait,

Commit a transaction

fn rollback<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<(), DbErr>> + Send + 'async_trait>>

where Self: 'async_trait,

Rolls back a transaction explicitly

impl TransactionTrait for RestrictedTransaction

fn transaction<'life0, 'async_trait, F, T, E>( &'life0 self, callback: F, ) -> Pin<Box<dyn Future<Output = Result<T, TransactionError<E>>> + Send + 'async_trait>>

where F: for<'c> FnOnce(&'c RestrictedTransaction) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>> + Send + 'async_trait, T: Send + 'async_trait, E: Display + Debug + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

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.

fn transaction_with_config<'life0, 'async_trait, F, T, E>( &'life0 self, callback: F, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>, ) -> Pin<Box<dyn Future<Output = Result<T, TransactionError<E>>> + Send + 'async_trait>>

where F: for<'c> FnOnce(&'c RestrictedTransaction) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>> + Send + 'async_trait, T: Send + 'async_trait, E: Display + Debug + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

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.

type Transaction = RestrictedTransaction

The concrete type for the transaction

fn begin<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<RestrictedTransaction, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute SQL BEGIN transaction. Returns a Transaction that can be committed or rolled back

fn begin_with_config<'life0, 'async_trait>( &'life0 self, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>, ) -> Pin<Box<dyn Future<Output = Result<RestrictedTransaction, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute SQL BEGIN transaction with isolation level and/or access mode. Returns a Transaction that can be committed or rolled back

fn begin_with_options<'life0, 'async_trait>( &'life0 self, options: TransactionOptions, ) -> Pin<Box<dyn Future<Output = Result<RestrictedTransaction, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute SQL BEGIN transaction with isolation level and/or access mode. Returns a Transaction that can be committed or rolled back