Struct Transaction

pub struct Transaction<'a, C>
where
    C: Prepare + ClientBorrowMut,
{ /* private fields */ }

Implementations

impl<C> Transaction<'_, C>

where C: Prepare + ClientBorrowMut,

pub fn builder() -> TransactionBuilder

pub async fn bind<'p>( &'p self, statement: &'p Statement, params: &[&(dyn ToSql + Sync)], ) -> Result<Portal<'p, C>, Error>

Binds a statement to a set of parameters, creating a Portal which can be incrementally queried.

Portals only last for the duration of the transaction in which they are created, and can only be used on the connection that created them.

pub async fn bind_raw<'p, I>( &'p self, statement: &'p Statement, params: I, ) -> Result<Portal<'p, C>, Error>

where I: AsParams,

A maximally flexible version of Transaction::bind.

pub async fn transaction(&mut self) -> Result<Transaction<'_, C>, Error>

Like Client::transaction, but creates a nested transaction via a savepoint.

pub async fn save_point<I>( &mut self, name: I, ) -> Result<Transaction<'_, C>, Error>

where I: Into<String>,

Like Client::transaction, but creates a nested transaction via a savepoint with the specified name.

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

Consumes the transaction, committing all changes made within it.

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

Rolls the transaction back, discarding all changes made within it.

This is equivalent to Transaction’s Drop implementation, but provides any error encountered to the caller.

Trait Implementations

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

where C: Prepare + ClientBorrowMut,

fn drop(&mut self)

Executes the destructor for this type.

impl<C> Prepare for Transaction<'_, C>

where C: Prepare + ClientBorrowMut,

fn _get_type( &self, oid: Oid, ) -> Pin<Box<dyn Future<Output = Result<Type, Error>> + Send + '_>>

fn _get_type_blocking(&self, oid: Oid) -> Result<Type, Error>

impl<C> Query for Transaction<'_, C>

where C: Prepare + ClientBorrowMut,

fn _send_encode_query<S>(&self, stmt: S) -> Result<(S::Output, Response), Error>

where S: Encode,

encode statement and params and send it to client driver

fn _query<S>( &self, stmt: S, ) -> Result<<S::Output as IntoResponse>::Response, Error>

where S: Encode,

query with statement and dynamic typed params.