Struct mysql_async::Transaction

pub struct Transaction<T>(_);

This struct represents MySql transaction.

Transaction it's a sugar for START TRANSACTION, ROLLBACK and COMMIT queries, so one should note that it is easy to mess things up calling this queries manually. Also you will get NestedTransaction error if you call transaction.start_transaction(_).

Methods

impl<T: Queryable + ConnectionLike> Transaction<T>

pub async fn commit(self) -> Result<T>

Returns future that will perform COMMIT query and resolve to a wrapped Queryable.

pub async fn rollback(self) -> Result<T>

Returns future that will perform ROLLBACK query and resolve to a wrapped Queryable.

Trait Implementations

impl<T: Queryable + ConnectionLike> Queryable for Transaction<T>

fn ping(self) -> BoxFuture<Self>

Returns future that resolves to Conn if COM_PING executed successfully.

fn disconnect(self) -> BoxFuture<()>

Returns future, that disconnects this connection from a server.

fn query<Q: AsRef<str>>(
    self,
    query: Q
) -> BoxFuture<QueryResult<Self, TextProtocol>>

Returns future that performs query.

fn first<Q, R>(self, query: Q) -> BoxFuture<(Self, Option<R>)> where
    Q: AsRef<str>,
    R: FromRow, 

Returns future that resolves to a first row of result of a query execution (if any).

fn drop_query<Q: AsRef<str>>(self, query: Q) -> BoxFuture<Self>

Returns future that performs query. Result will be dropped.

fn prepare<Q: AsRef<str>>(self, query: Q) -> BoxFuture<Stmt<Self>>

Returns future that prepares statement.

fn prep_exec<Q, P>(
    self,
    query: Q,
    params: P
) -> BoxFuture<QueryResult<Self, BinaryProtocol>> where
    Q: AsRef<str>,
    P: Into<Params>, 

Returns future that prepares and executes statement in one pass.

fn first_exec<Q, P, R>(
    self,
    query: Q,
    params: P
) -> BoxFuture<(Self, Option<R>)> where
    Q: AsRef<str>,
    P: Into<Params>,
    R: FromRow, 

Returns future that resolves to a first row of result of a statement execution (if any).

fn drop_exec<Q, P>(self, query: Q, params: P) -> BoxFuture<Self> where
    Q: AsRef<str>,
    P: Into<Params>, 

Returns future that prepares and executes statement. Result will be dropped.

fn batch_exec<Q, I, P>(self, query: Q, params_iter: I) -> BoxFuture<Self> where
    Q: AsRef<str>,
    I: IntoIterator<Item = P> + Send + 'static,
    I::IntoIter: Send + 'static,
    Params: From<P>,
    P: Send + 'static, 

Returns future that prepares statement and performs batch execution. Results will be dropped.

fn start_transaction(
    self,
    options: TransactionOptions
) -> BoxFuture<Transaction<Self>>

Returns future that starts transaction.