Struct diesel_async::AsyncMysqlConnection

pub struct AsyncMysqlConnection { /* private fields */ }

Available on crate feature mysql only.

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) -> ConnectionResult<Self>

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 Backend = Mysql

The backend this type connects to

fn establish<'life0, 'async_trait>(
    database_url: &'life0 str
) -> Pin<Box<dyn Future<Output = ConnectionResult<Self>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Establishes a new connection to the database

fn transaction<'life0, 'async_trait, R, E, F>(
    &'life0 mut self,
    callback: F
) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'async_trait>>where
    F: FnOnce(&mut Self) -> BoxFuture<'_, Result<R, E>> + Send,
    E: From<Error> + Send,
    R: Send,
    R: 'async_trait,
    E: 'async_trait,
    F: 'async_trait,
    'life0: '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 = QueryResult<()>> + 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

impl<'conn, 'query> AsyncConnectionGatWorkaround<'conn, 'query, Mysql> for AsyncMysqlConnection

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

The future returned by AsyncConnection::execute

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

The future returned by AsyncConnection::load

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

The inner stream returned by AsyncConnection::load

type Row = MysqlRow

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

impl SimpleAsyncConnection for AsyncMysqlConnection

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

Execute multiple SQL statements within the same string.

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

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

See the traits documentation.