Struct Transaction

pub struct Transaction<'a> { /* private fields */ }

Implementations

impl Transaction<'_>

pub fn commit(self) -> Result<(), Error>

Will consume and commit transaction.

pub fn rollback(self) -> Result<(), Error>

Will consume and rollback transaction. You also can rely on Drop implementation but it will swallow errors.

pub fn set_local_infile_handler(&mut self, handler: Option<LocalInfileHandler>)

A way to override local infile handler for this transaction. Destructor of transaction will restore original handler.

pub fn affected_rows(&self) -> u64

Returns the number of affected rows, reported by the server.

pub fn last_insert_id(&self) -> Option<u64>

Returns the last insert id of the last query, if any.

pub fn warnings(&self) -> u16

Returns the warnings count, reported by the server.

pub fn info_ref(&self) -> &[u8]

Info, reported by the server.

Will be empty if not defined.

pub fn info_str(&self) -> Cow<'_, str>

Info, reported by the server.

Will be empty if not defined.

Trait Implementations

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

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Drop for Transaction<'a>

fn drop(&mut self)

Will rollback transaction.

impl<'a> Queryable for Transaction<'a>

fn query_iter<T>( &mut self, query: T, ) -> Result<QueryResult<'_, '_, '_, Text>, Error>

where T: AsRef<str>,

Performs text query.

fn prep<T>(&mut self, query: T) -> Result<Statement, Error>

where T: AsRef<str>,

Prepares the given query as a prepared statement.

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

This function will close the given statement on the server side.

fn exec_iter<S, P>( &mut self, stmt: S, params: P, ) -> Result<QueryResult<'_, '_, '_, Binary>, Error>

where S: AsStatement, P: Into<Params>,

Executes the given stmt with the given params.

fn query<T, Q>(&mut self, query: Q) -> Result<Vec<T>, Error>

where Q: AsRef<str>, T: FromRow,

Performs text query and collects the first result set.

fn query_opt<T, Q>( &mut self, query: Q, ) -> Result<Vec<Result<T, FromRowError>>, Error>

where Q: AsRef<str>, T: FromRow,

Same as Queryable::query but useful when you not sure what your schema is.

fn query_first<T, Q>(&mut self, query: Q) -> Result<Option<T>, Error>

where Q: AsRef<str>, T: FromRow,

Performs text query and returns the first row of the first result set.

fn query_first_opt<T, Q>( &mut self, query: Q, ) -> Result<Option<Result<T, FromRowError>>, Error>

where Q: AsRef<str>, T: FromRow,

Same as Queryable::query_first but useful when you not sure what your schema is.

fn query_map<T, F, Q, U>(&mut self, query: Q, f: F) -> Result<Vec<U>, Error>

where Q: AsRef<str>, T: FromRow, F: FnMut(T) -> U,

Performs text query and maps each row of the first result set.

fn query_map_opt<T, F, Q, U>(&mut self, query: Q, f: F) -> Result<Vec<U>, Error>

where Q: AsRef<str>, T: FromRow, F: FnMut(Result<T, FromRowError>) -> U,

Same as Queryable::query_map but useful when you not sure what your schema is.

fn query_fold<T, F, Q, U>( &mut self, query: Q, init: U, f: F, ) -> Result<U, Error>

where Q: AsRef<str>, T: FromRow, F: FnMut(U, T) -> U,

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

fn query_fold_opt<T, F, Q, U>( &mut self, query: Q, init: U, f: F, ) -> Result<U, Error>

where Q: AsRef<str>, T: FromRow, F: FnMut(U, Result<T, FromRowError>) -> U,

Same as Queryable::query_fold but useful when you not sure what your schema is.

fn query_drop<Q>(&mut self, query: Q) -> Result<(), Error>

where Q: AsRef<str>,

Performs text query and drops the query result.

fn exec_batch<S, P, I>(&mut self, stmt: S, params: I) -> Result<(), Error>

where Self: Sized, S: AsStatement, P: Into<Params>, I: IntoIterator<Item = P>,

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

fn exec<T, S, P>(&mut self, stmt: S, params: P) -> Result<Vec<T>, Error>

where S: AsStatement, P: Into<Params>, T: FromRow,

Executes the given stmt and collects the first result set.

fn exec_opt<T, S, P>( &mut self, stmt: S, params: P, ) -> Result<Vec<Result<T, FromRowError>>, Error>

where S: AsStatement, P: Into<Params>, T: FromRow,

Same as Queryable::exec but useful when you not sure what your schema is.

fn exec_first<T, S, P>( &mut self, stmt: S, params: P, ) -> Result<Option<T>, Error>

where S: AsStatement, P: Into<Params>, T: FromRow,

Executes the given stmt and returns the first row of the first result set.

fn exec_first_opt<T, S, P>( &mut self, stmt: S, params: P, ) -> Result<Option<Result<T, FromRowError>>, Error>

where S: AsStatement, P: Into<Params>, T: FromRow,

Same as Queryable::exec_first but useful when you not sure what your schema is.

fn exec_map<T, S, P, F, U>( &mut self, stmt: S, params: P, f: F, ) -> Result<Vec<U>, Error>

where S: AsStatement, P: Into<Params>, T: FromRow, F: FnMut(T) -> U,

Executes the given stmt and maps each row of the first result set.

fn exec_map_opt<T, S, P, F, U>( &mut self, stmt: S, params: P, f: F, ) -> Result<Vec<U>, Error>

where S: AsStatement, P: Into<Params>, T: FromRow, F: FnMut(Result<T, FromRowError>) -> U,

Same as Queryable::exec_map but useful when you not sure what your schema is.

fn exec_fold<T, S, P, U, F>( &mut self, stmt: S, params: P, init: U, f: F, ) -> Result<U, Error>

where S: AsStatement, P: Into<Params>, T: FromRow, F: FnMut(U, T) -> U,

Executes the given stmt and folds the first result set to a single value.

fn exec_fold_opt<T, S, P, U, F>( &mut self, stmt: S, params: P, init: U, f: F, ) -> Result<U, Error>

where S: AsStatement, P: Into<Params>, T: FromRow, F: FnMut(U, Result<T, FromRowError>) -> U,

Same as Queryable::exec_fold but useful when you not sure what your schema is.

fn exec_drop<S, P>(&mut self, stmt: S, params: P) -> Result<(), Error>

where S: AsStatement, P: Into<Params>,

Executes the given stmt and drops the result.