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 fn transaction<F, T, E>( &self, callback: F, ) -> Result<T, TransactionError<E>>

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

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 fn transaction_with_config<F, T, E>( &self, callback: F, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>, ) -> Result<T, TransactionError<E>>

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

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 fn commit(self) -> Result<(), DbErr>

Commit a transaction

pub 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(&self, stmt: Statement) -> Result<ExecResult, DbErr>

Execute a Statement

fn execute<S: StatementBuilder>(&self, stmt: &S) -> Result<ExecResult, DbErr>

Execute a [QueryStatement]

fn execute_unprepared(&self, sql: &str) -> Result<ExecResult, DbErr>

Execute a unprepared Statement

fn query_one_raw(&self, stmt: Statement) -> Result<Option<QueryResult>, DbErr>

Execute a Statement and return a single row of QueryResult

fn query_one<S: StatementBuilder>( &self, stmt: &S, ) -> Result<Option<QueryResult>, DbErr>

Execute a [QueryStatement] and return a single row of QueryResult

fn query_all_raw(&self, stmt: Statement) -> Result<Vec<QueryResult>, DbErr>

Execute a Statement and return a vector of QueryResult

fn query_all<S: StatementBuilder>( &self, stmt: &S, ) -> Result<Vec<QueryResult>, DbErr>

Execute a [QueryStatement] 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(self) -> Result<(), DbErr>

Commit a transaction

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

Rolls back a transaction explicitly

impl TransactionTrait for RestrictedTransaction

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

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

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<F, T, E>( &self, callback: F, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>, ) -> Result<T, TransactionError<E>>

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

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(&self) -> Result<RestrictedTransaction, DbErr>

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

fn begin_with_config( &self, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>, ) -> Result<RestrictedTransaction, DbErr>

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( &self, options: TransactionOptions, ) -> Result<RestrictedTransaction, DbErr>

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