Struct rocket_db_pools::diesel::AsyncMysqlConnection

pub struct AsyncMysqlConnection { /* private fields */ }

A connection to a MySQL database. Connection URLs should be in the form mysql://[user[:password]@]host/database_name

Implementations

impl AsyncMysqlConnection

pub async fn try_from( conn: Conn, ) -> Result<AsyncMysqlConnection, ConnectionError>

Wrap an existing mysql_async::Conn into a async diesel mysql connection

This function constructs a new AsyncMysqlConnection based on an existing [mysql_async::Conn].

Trait Implementations

impl AsyncConnection for AsyncMysqlConnection

type ExecuteFuture<'conn, 'query> = Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'conn>>

The future returned by AsyncConnection::execute

type LoadFuture<'conn, 'query> = Pin<Box<dyn Future<Output = Result<<AsyncMysqlConnection as AsyncConnection>::Stream<'conn, 'query>, Error>> + Send + 'conn>>

The future returned by AsyncConnection::load

type Stream<'conn, 'query> = Pin<Box<dyn Stream<Item = Result<<AsyncMysqlConnection as AsyncConnection>::Row<'conn, 'query>, Error>> + Send + 'conn>>

The inner stream returned by AsyncConnection::load

type Row<'conn, 'query> = MysqlRow

The row type used by the stream returned by AsyncConnection::load

type Backend = Mysql

The backend this type connects to

fn establish<'life0, 'async_trait>( database_url: &'life0 str, ) -> Pin<Box<dyn Future<Output = Result<AsyncMysqlConnection, ConnectionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, AsyncMysqlConnection: 'async_trait,

Establishes a new connection to the database

fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)

Set a specific Instrumentation implementation for this connection

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

where 'a: 'async_trait, 'life0: 'async_trait, F: for<'r> FnOnce(&'r mut Self) -> Pin<Box<dyn ScopedFuture<'a, 'r, PhantomData<&'r &'a ()>, Output = Result<R, E>> + Send + 'r>> + Send + 'a + 'async_trait, E: From<Error> + Send + 'a + 'async_trait, R: Send + 'a + 'async_trait, Self: 'async_trait,

Executes the given function inside of a database transaction

fn begin_test_transaction<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Creates a transaction that will never be committed. This is useful for tests. Panics if called while inside of a transaction or if called with a connection containing a broken transaction

fn test_transaction<'a, 'async_trait, R, E, F>( &'a mut self, f: F, ) -> Pin<Box<dyn Future<Output = R> + Send + 'async_trait>>

where 'a: 'async_trait, F: for<'r> FnOnce(&'r mut Self) -> Pin<Box<dyn ScopedFuture<'a, 'r, PhantomData<&'r &'a ()>, Output = Result<R, E>> + Send + 'r>> + Send + 'a + 'async_trait, E: Debug + Send + 'a + 'async_trait, R: Send + 'a + 'async_trait, Self: 'a + 'async_trait,

Executes the given function inside a transaction, but does not commit it. Panics if the given function returns an error.

impl SimpleAsyncConnection for AsyncMysqlConnection

fn batch_execute<'life0, 'life1, 'async_trait>( &'life0 mut self, query: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, AsyncMysqlConnection: 'async_trait,

Execute multiple SQL statements within the same string.

impl<'b, Changes, Output> UpdateAndFetchResults<Changes, Output> for AsyncMysqlConnection

where Output: Send, Changes: Copy + Identifiable + Send + AsChangeset<Target = <Changes as HasTable>::Table> + IntoUpdateTarget, <Changes as HasTable>::Table: FindDsl<<Changes as Identifiable>::Id> + Send, <Changes as IntoUpdateTarget>::WhereClause: Send, <Changes as AsChangeset>::Changeset: Send, <Changes as Identifiable>::Id: Send, UpdateStatement<<Changes as HasTable>::Table, <Changes as IntoUpdateTarget>::WhereClause, <Changes as AsChangeset>::Changeset>: ExecuteDsl<AsyncMysqlConnection>, <<Changes as HasTable>::Table as FindDsl<<Changes as Identifiable>::Id>>::Output: LoadQuery<'b, AsyncMysqlConnection, Output> + Send + 'b, <<Changes as HasTable>::Table as Table>::AllColumns: ValidGrouping<()>, <<<Changes as HasTable>::Table as Table>::AllColumns as ValidGrouping<()>>::IsAggregate: MixedAggregates<No, Output = No>, <<Changes as HasTable>::Table as QuerySource>::FromClause: Send,

fn update_and_fetch<'life0, 'async_trait>( &'life0 mut self, changeset: Changes, ) -> Pin<Box<dyn Future<Output = Result<Output, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Changes: 'async_trait, AsyncMysqlConnection: 'async_trait,

See the traits documentation.