Struct Database

pub struct Database(/* private fields */);

Handle to a pool of database connections

Executing sql statements is done through the Executor trait which is implemented on &Database.

Common operations are implemented as functions in the database module.

Cloning is cheap i.e. two Arcs.

Implementations

impl Database

pub async fn connect( configuration: DatabaseConfiguration, ) -> Result<Self, Error>

Connects to the database using configuration

pub async fn raw_sql<'a>( &self, query_string: &'a str, bind_params: Option<&[Value<'a>]>, transaction: Option<&mut Transaction>, ) -> Result<Vec<Row>, Error>

👎Deprecated: Use Executor::execute instead

Execute raw SQL statements on the database.

If possible, the statement is executed as prepared statement.

To bind parameter, use ? as placeholder in SQLite and MySQL and $1, $2, $n in Postgres.

Parameter:

• query_string: Reference to a valid SQL query.
• bind_params: Optional list of values to bind in the query.
• transaction: Optional transaction to execute the query on.

Returns a list of rows. If there are no values to retrieve, an empty list is returned.

pub async fn start_transaction(&self) -> Result<Transaction, Error>

Starts a new transaction

&mut Transaction implements Executor like &Database does but its database operations can be reverted using Transaction::rollback or simply dropping the transaction without calling Transaction::commit.

pub async fn close(self)

Closes the database connection

While calling this method is not strictly necessary, terminating your program without it might result in some final queries not being flushed properly.

This method consumes the database handle, but actually all handles created using clone will become invalid after this call. This means any further operation would result in an Err

Trait Implementations

impl Clone for Database

fn clone(&self) -> Database

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Drop for Database

fn drop(&mut self)

Checks whether Database::close has been called before the last instance is dropped

impl<'executor> Executor<'executor> for &'executor Database

type EnsureTransactionFuture = Pin<Box<dyn Future<Output = Result<TransactionGuard<'executor>, Error>> + Send + 'executor>>

A future producing a TransactionGuard returned by ensure_transaction

fn execute<'data, 'result, Q>( self, query: String, values: Vec<Value<'data>>, ) -> Q::Result<'result>

where Q: QueryStrategy, 'executor: 'result, 'data: 'result,

Executes a raw SQL query

fn into_dyn(self) -> DynamicExecutor<'executor>

Convenience method to convert into a “dyn Executor”

fn dialect(&self) -> DBImpl

Get the executor’s sql dialect.

fn ensure_transaction( self, ) -> Pin<Box<dyn Future<Output = Result<TransactionGuard<'executor>, Error>> + Send + 'executor>>

Ensure a piece of code is run inside a transaction using a TransactionGuard.