Struct DatabaseConnection 

#[non_exhaustive]
pub struct DatabaseConnection {
    pub inner: DatabaseConnectionType,
    /* private fields */
}

Handle a database connection depending on the backend enabled by the feature flags. This creates a connection pool internally (for SQLx connections), and so is cheap to clone.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

inner: DatabaseConnectionType

DatabaseConnection used to be a enum. Now it’s moved into inner, because we have to attach other contexts.

Implementations

impl DatabaseConnection

pub fn as_mock_connection(&self) -> &MockDatabaseConnection

Available on crate feature mock only.

Generate a database connection for testing the Mock database

Panics

Panics if DbConn is not a mock connection.

pub fn into_transaction_log(self) -> Vec<Transaction>

Available on crate feature mock only.

Get the transaction log as a collection Vec<crate::Transaction>

Panics

Panics if the mocker mutex is being held by another thread.

impl DatabaseConnection

pub fn as_proxy_connection(&self) -> &ProxyDatabaseConnection

Available on crate feature proxy only.

Generate a database connection for testing the Proxy database

Panics

Panics if DbConn is not a proxy connection.

impl DatabaseConnection

pub fn load_rbac(&self) -> Result<(), DbErr>

Available on crate feature rbac only.

Load RBAC data from the same database as this connection and setup RBAC engine. If the RBAC engine already exists, it will be replaced.

pub fn load_rbac_from(&self, db: &DbConn) -> Result<(), DbErr>

Available on crate feature rbac only.

Load RBAC data from the given database connection and setup RBAC engine. This could be from another database.

pub fn replace_rbac(&self, engine: RbacEngine)

Available on crate feature rbac only.

Replace the internal RBAC engine.

pub fn restricted_for( &self, user_id: RbacUserId, ) -> Result<RestrictedConnection, DbErr>

Available on crate feature rbac only.

Create a restricted connection with access control specific for the user.

impl DatabaseConnection

pub fn get_database_backend(&self) -> DbBackend

Get the database backend for this connection

Panics

Panics if DatabaseConnection is Disconnected.

pub fn get_schema_builder(&self) -> SchemaBuilder

Creates a SchemaBuilder for this backend

pub fn set_metric_callback<F>(&mut self, _callback: F)

where F: Fn(&Info<'_>) + 'static,

Sets a callback to metric this connection

pub fn ping(&self) -> Result<(), DbErr>

Checks if a connection to the database is still valid.

pub fn close(self) -> Result<(), DbErr>

Explicitly close the database connection. See Self::close_by_ref for usage with references.

pub fn close_by_ref(&self) -> Result<(), DbErr>

Explicitly close the database connection

Trait Implementations

impl Clone for DatabaseConnection

fn clone(&self) -> DatabaseConnection

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConnectionTrait for DatabaseConnection

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_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_all_raw(&self, stmt: Statement) -> Result<Vec<QueryResult>, DbErr>

Execute a Statement and return a vector of QueryResult

fn is_mock_connection(&self) -> bool

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

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

Execute a [QueryStatement]

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<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

impl Debug for DatabaseConnection

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

Formats the value using the given formatter.

impl Default for DatabaseConnection

fn default() -> Self

Returns the “default value” for a type.

impl From<DatabaseConnectionType> for DatabaseConnection

fn from(inner: DatabaseConnectionType) -> Self

Converts to this type from the input type.

impl StreamTrait for DatabaseConnection

type Stream<'a> = QueryStream

Create a stream for the QueryResult

fn get_database_backend(&self) -> DbBackend

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

fn stream_raw<'a>(&'a self, stmt: Statement) -> Result<Self::Stream<'a>, DbErr>

Execute a Statement and return a stream of results

fn stream<'a, S: StatementBuilder>( &'a self, stmt: &S, ) -> Result<Self::Stream<'a>, DbErr>

Execute a [QueryStatement] and return a stream of results

impl TransactionTrait for DatabaseConnection

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

where F: for<'c> FnOnce(&'c DatabaseTransaction) -> 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 DatabaseTransaction) -> 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 = DatabaseTransaction

The concrete type for the transaction

fn begin(&self) -> Result<DatabaseTransaction, 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<DatabaseTransaction, DbErr>

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