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

async fn establish(database_url: &str) -> ConnectionResult<Self>

Establishes a new connection to the database

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

Set a specific Instrumentation implementation for this connection

fn set_prepared_statement_cache_size(&mut self, size: CacheSize)

Set the prepared statement cache size to CacheSize for this connection

fn transaction<'a, 'conn, R, E, F>( &'conn mut self, callback: F, ) -> BoxFuture<'conn, Result<R, E>>

where F: for<'r> FnOnce(&'r mut Self) -> ScopedBoxFuture<'a, 'r, Result<R, E>> + Send + 'a, E: From<Error> + Send + 'a, R: Send + 'a, 'a: 'conn,

Executes the given function inside of a database transaction

fn begin_test_transaction( &mut self, ) -> impl Future<Output = QueryResult<()>> + Send

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<'conn, 'a, R, E, F>( &'conn mut self, f: F, ) -> impl Future<Output = R> + Send + 'conn

where F: for<'r> FnOnce(&'r mut Self) -> ScopedBoxFuture<'a, 'r, Result<R, E>> + Send + 'a, E: Debug + Send + 'a, R: Send + 'a, 'a: 'conn,

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

impl SimpleAsyncConnection for AsyncMysqlConnection

async fn batch_execute(&mut self, query: &str) -> QueryResult<()>

Execute multiple SQL statements within the same string.

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

where Output: Send + 'static, Changes: Copy + AsChangeset<Target = Tab> + Send + Identifiable<Table = Tab>, Tab: Table + FindDsl<Changes::Id> + 'b, Find<Tab, Changes::Id>: IntoUpdateTarget<Table = Tab, WhereClause = V>, UpdateStatement<Tab, V, Changes::Changeset>: AsQuery, Update<Changes, Changes>: ExecuteDsl<Self>, V: Send + 'b, Changes::Changeset: Send + 'b, Changes::Id: 'b, Tab::FromClause: Send, Find<Changes::Table, Changes::Id>: LoadQuery<'b, AsyncMysqlConnection, Output> + Send,

fn update_and_fetch<'conn, 'changes>( &'conn mut self, changeset: Changes, ) -> BoxFuture<'changes, QueryResult<Output>>

where Changes: 'changes, Changes::Changeset: 'changes, Self: 'changes, 'conn: 'changes,

See the traits documentation.