Struct mysql_async::Transaction

pub struct Transaction<'a>(_);

This struct represents MySql transaction.

Transaction is just 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<'a> Transaction<'a>

pub async fn commit(__arg0: Self) -> Result<()>

Performs COMMIT query.

pub async fn rollback(__arg0: Self) -> Result<()>

Performs ROLLBACK query.

Trait Implementations

impl<'a> Debug for Transaction<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'_> Drop for Transaction<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl<'_> Queryable for Transaction<'_>

fn ping(&mut self) -> BoxFuture<()>

Executes COM_PING.

fn query_iter<'a, Q>(
    &'a mut self,
    query: Q
) -> BoxFuture<'a, QueryResult<'a, 'static, TextProtocol>> where
    Q: AsRef<str> + Send + Sync + 'a, 

Performs the given query.

fn prep<'a, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Statement> where
    Q: AsRef<str> + Sync + Send + 'a, 

Prepares the given statement.

fn close(&mut self, stmt: Statement) -> BoxFuture<()>

Closes the given statement.

fn exec_iter<'a: 's, 's, Q: ?Sized, P>(
    &'a mut self,
    stmt: &'s Q,
    params: P
) -> BoxFuture<'s, QueryResult<'a, 'static, BinaryProtocol>> where
    Q: StatementLike + 'a,
    P: Into<Params>, 

Executes the given statement with the given params.

fn query<'a, T, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Vec<T>> where
    Q: AsRef<str> + Send + Sync + 'a,
    T: FromRow + Send + 'static, 

Performs the given query and collects the first result set.

fn query_first<'a, T, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Option<T>> where
    Q: AsRef<str> + Send + Sync + 'a,
    T: FromRow + Send + 'static, 

Performs the given query and returns the firt row of the first result set.

fn query_map<'a, T, F, Q, U>(
    &'a mut self,
    query: Q,
    f: F
) -> BoxFuture<'a, Vec<U>> where
    Q: AsRef<str> + Send + Sync + 'a,
    T: FromRow + Send + 'static,
    F: FnMut(T) -> U + Send + 'a,
    U: Send, 

Performs the given query and returns the firt row of the first result set.

fn query_fold<'a, T, F, Q, U>(
    &'a mut self,
    query: Q,
    init: U,
    f: F
) -> BoxFuture<'a, U> where
    Q: AsRef<str> + Send + Sync + 'a,
    T: FromRow + Send + 'static,
    F: FnMut(U, T) -> U + Send + 'a,
    U: Send + 'a, 

Performs the given query and folds the first result set to a single value.

fn query_drop<'a, Q>(&'a mut self, query: Q) -> BoxFuture<'a, ()> where
    Q: AsRef<str> + Send + Sync + 'a, 

Performs the given query and drops the query result.

fn exec_batch<'a: 'b, 'b, S: ?Sized, P, I>(
    &'a mut self,
    stmt: &'b S,
    params_iter: I
) -> BoxFuture<'b, ()> where
    S: StatementLike + 'b,
    I: IntoIterator<Item = P> + Send + 'b,
    I::IntoIter: Send,
    P: Into<Params> + Send, 

Prepares the given statement, and exectues it with each item in the given params iterator.

fn exec<'a: 'b, 'b, T, S: ?Sized, P>(
    &'a mut self,
    stmt: &'b S,
    params: P
) -> BoxFuture<'b, Vec<T>> where
    S: StatementLike + 'b,
    P: Into<Params> + Send + 'b,
    T: FromRow + Send + 'static, 

Exectues the given statement and collects the first result set.

fn exec_first<'a: 'b, 'b, T, S: ?Sized, P>(
    &'a mut self,
    stmt: &'b S,
    params: P
) -> BoxFuture<'b, Option<T>> where
    S: StatementLike + 'b,
    P: Into<Params> + Send + 'b,
    T: FromRow + Send + 'static, 

Exectues the given statement and returns the first row of the first result set.

fn exec_map<'a: 'b, 'b, T, S: ?Sized, P, U, F>(
    &'a mut self,
    stmt: &'b S,
    params: P,
    f: F
) -> BoxFuture<'b, Vec<U>> where
    S: StatementLike + 'b,
    P: Into<Params> + Send + 'b,
    T: FromRow + Send + 'static,
    F: FnMut(T) -> U + Send + 'a,
    U: Send + 'a, 

Exectues the given stmt and folds the first result set to a signel value.

fn exec_fold<'a: 'b, 'b, T, S: ?Sized, P, U, F>(
    &'a mut self,
    stmt: &'b S,
    params: P,
    init: U,
    f: F
) -> BoxFuture<'b, U> where
    S: StatementLike + 'b,
    P: Into<Params> + Send + 'b,
    T: FromRow + Send + 'static,
    F: FnMut(U, T) -> U + Send + 'a,
    U: Send + 'a, 

Exectues the given stmt and folds the first result set to a signel value.

fn exec_drop<'a: 'b, 'b, S: ?Sized, P>(
    &'a mut self,
    stmt: &'b S,
    params: P
) -> BoxFuture<'b, ()> where
    S: StatementLike + 'b,
    P: Into<Params> + Send + 'b, 

Exectues the given statement and drops the result.

impl<'a, 't> ToConnection<'a, 't> for &'a mut Transaction<'t>