Struct deadpool_postgres::Transaction

pub struct Transaction<'a> {
    pub statement_cache: Arc<StatementCache>,
    /* private fields */
}

Wrapper around tokio_postgres::Transaction with a StatementCache from the Client object it was created by.

Fields

statement_cache: Arc<StatementCache>

StatementCache of this Transaction.

Implementations

impl<'a> Transaction<'a>

pub async fn prepare_cached(&self, query: &str) -> Result<Statement, Error>

Like tokio_postgres::Transaction::prepare(), but uses an existing Statement from the StatementCache if possible.

pub async fn prepare_typed_cached(
    &self,
    query: &str,
    types: &[Type]
) -> Result<Statement, Error>

Like tokio_postgres::Transaction::prepare_typed(), but uses an existing Statement from the StatementCache if possible.

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

Like tokio_postgres::Transaction::commit().

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

Like tokio_postgres::Transaction::rollback().

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

Like tokio_postgres::Transaction::transaction(), but returns a wrapped Transaction with a StatementCache.

pub async fn savepoint<I>(&mut self, name: I) -> Result<Transaction<'_>, Error>where
    I: Into<String>,

Like tokio_postgres::Transaction::savepoint(), but returns a wrapped Transaction with a StatementCache.

Methods from Deref<Target = PgTransaction<'a>>

pub async fn prepare(
    &self,
    query: &str
) -> impl Future<Output = Result<Statement, Error>>

Like Client::prepare.

pub async fn prepare_typed(
    &self,
    query: &str,
    parameter_types: &[Type]
) -> impl Future<Output = Result<Statement, Error>>

Like Client::prepare_typed.

pub async fn query<T>(
    &self,
    statement: &T,
    params: &[&(dyn ToSql + Sync)]
) -> impl Future<Output = Result<Vec<Row, Global>, Error>>where
    T: ToStatement + ?Sized,

Like Client::query.

pub async fn query_one<T>(
    &self,
    statement: &T,
    params: &[&(dyn ToSql + Sync)]
) -> impl Future<Output = Result<Row, Error>>where
    T: ToStatement + ?Sized,

Like Client::query_one.

pub async fn query_opt<T>(
    &self,
    statement: &T,
    params: &[&(dyn ToSql + Sync)]
) -> impl Future<Output = Result<Option<Row>, Error>>where
    T: ToStatement + ?Sized,

Like Client::query_opt.

pub async fn query_raw<T, P, I>(
    &self,
    statement: &T,
    params: I
) -> impl Future<Output = Result<RowStream, Error>>where
    T: ToStatement + ?Sized,
    P: BorrowToSql,
    I: IntoIterator<Item = P>,
    <I as IntoIterator>::IntoIter: ExactSizeIterator,

Like Client::query_raw.

pub async fn execute<T>(
    &self,
    statement: &T,
    params: &[&(dyn ToSql + Sync)]
) -> impl Future<Output = Result<u64, Error>>where
    T: ToStatement + ?Sized,

Like Client::execute.

pub async fn execute_raw<P, I, T>(
    &self,
    statement: &T,
    params: I
) -> impl Future<Output = Result<u64, Error>>where
    T: ToStatement + ?Sized,
    P: BorrowToSql,
    I: IntoIterator<Item = P>,
    <I as IntoIterator>::IntoIter: ExactSizeIterator,

Like Client::execute_iter.

pub async fn bind<T>(
    &self,
    statement: &T,
    params: &[&(dyn ToSql + Sync)]
) -> impl Future<Output = Result<Portal, Error>>where
    T: ToStatement + ?Sized,

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.

Panics

Panics if the number of parameters provided does not match the number expected.

pub async fn bind_raw<P, T, I>(
    &self,
    statement: &T,
    params: I
) -> impl Future<Output = Result<Portal, Error>>where
    T: ToStatement + ?Sized,
    P: BorrowToSql,
    I: IntoIterator<Item = P>,
    <I as IntoIterator>::IntoIter: ExactSizeIterator,

A maximally flexible version of bind.

pub async fn query_portal(
    &self,
    portal: &Portal,
    max_rows: i32
) -> impl Future<Output = Result<Vec<Row, Global>, Error>>

Continues execution of a portal, returning a stream of the resulting rows.

Unlike query, portals can be incrementally evaluated by limiting the number of rows returned in each call to query_portal. If the requested number is negative or 0, all rows will be returned.

pub async fn query_portal_raw(
    &self,
    portal: &Portal,
    max_rows: i32
) -> impl Future<Output = Result<RowStream, Error>>

The maximally flexible version of query_portal.

pub async fn copy_in<T, U>(
    &self,
    statement: &T
) -> impl Future<Output = Result<CopyInSink<U>, Error>>where
    T: ToStatement + ?Sized,
    U: Buf + 'static + Send,

Like Client::copy_in.

pub async fn copy_out<T>(
    &self,
    statement: &T
) -> impl Future<Output = Result<CopyOutStream, Error>>where
    T: ToStatement + ?Sized,

Like Client::copy_out.

pub async fn simple_query(
    &self,
    query: &str
) -> impl Future<Output = Result<Vec<SimpleQueryMessage, Global>, Error>>

Like Client::simple_query.

pub async fn batch_execute(
    &self,
    query: &str
) -> impl Future<Output = Result<(), Error>>

Like Client::batch_execute.

pub fn cancel_token(&self) -> CancelToken

Like Client::cancel_token.

pub async fn cancel_query<T>(
    &self,
    tls: T
) -> impl Future<Output = Result<(), Error>>where
    T: MakeTlsConnect<Socket>,

👎Deprecated since 0.6.0: use Transaction::cancel_token() instead

Like Client::cancel_query.

pub async fn cancel_query_raw<S, T>(
    &self,
    stream: S,
    tls: T
) -> impl Future<Output = Result<(), Error>>where
    S: AsyncRead + AsyncWrite + Unpin,
    T: TlsConnect<S>,

👎Deprecated since 0.6.0: use Transaction::cancel_token() instead

Like Client::cancel_query_raw.

pub async fn transaction(
    &mut self
) -> impl Future<Output = Result<Transaction<'_>, Error>>

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

pub async fn savepoint<I>(
    &mut self,
    name: I
) -> impl Future<Output = Result<Transaction<'_>, Error>>where
    I: Into<String>,

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

pub fn client(&self) -> &Client

Returns a reference to the underlying Client.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<'a> Deref for Transaction<'a>

type Target = Transaction<'a>

The resulting type after dereferencing.

fn deref(&self) -> &PgTransaction<'a>

Dereferences the value.

impl<'a> DerefMut for Transaction<'a>

fn deref_mut(&mut self) -> &mut PgTransaction<'a>

Mutably dereferences the value.

impl<'impl0> GenericClient for Transaction<'impl0>

fn execute<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    query: &'life1 T,
    params: &'life2 [&'life3 (dyn ToSql + Sync)]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    T: ?Sized + ToStatement + Sync + Send + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,

Like Client::execute.

fn execute_raw<'life0, 'life1, 'async_trait, P, I, T>(
    &'life0 self,
    statement: &'life1 T,
    params: I
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>>where
    T: ?Sized + ToStatement + Sync + Send + 'async_trait,
    P: BorrowToSql + 'async_trait,
    I: IntoIterator<Item = P> + Sync + Send + 'async_trait,
    I::IntoIter: ExactSizeIterator,
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Like Client::execute_raw.

fn query<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    query: &'life1 T,
    params: &'life2 [&'life3 (dyn ToSql + Sync)]
) -> Pin<Box<dyn Future<Output = Result<Vec<Row>, Error>> + Send + 'async_trait>>where
    T: ?Sized + ToStatement + Sync + Send + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,

Like Client::query.

fn query_one<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    statement: &'life1 T,
    params: &'life2 [&'life3 (dyn ToSql + Sync)]
) -> Pin<Box<dyn Future<Output = Result<Row, Error>> + Send + 'async_trait>>where
    T: ?Sized + ToStatement + Sync + Send + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,

Like Client::query_one.

fn query_opt<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    statement: &'life1 T,
    params: &'life2 [&'life3 (dyn ToSql + Sync)]
) -> Pin<Box<dyn Future<Output = Result<Option<Row>, Error>> + Send + 'async_trait>>where
    T: ?Sized + ToStatement + Sync + Send + 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,

Like Client::query_opt.

fn query_raw<'life0, 'life1, 'async_trait, T, P, I>(
    &'life0 self,
    statement: &'life1 T,
    params: I
) -> Pin<Box<dyn Future<Output = Result<RowStream, Error>> + Send + 'async_trait>>where
    T: ?Sized + ToStatement + Sync + Send + 'async_trait,
    P: BorrowToSql + 'async_trait,
    I: IntoIterator<Item = P> + Sync + Send + 'async_trait,
    I::IntoIter: ExactSizeIterator,
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Like Client::query_raw.

fn prepare<'life0, 'life1, 'async_trait>(
    &'life0 self,
    query: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Statement, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Like Client::prepare.

fn prepare_typed<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    query: &'life1 str,
    parameter_types: &'life2 [Type]
) -> Pin<Box<dyn Future<Output = Result<Statement, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Like Client::prepare_typed.

fn prepare_cached<'life0, 'life1, 'async_trait>(
    &'life0 self,
    query: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Statement, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Like Client::prepare_cached.

fn prepare_typed_cached<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    query: &'life1 str,
    types: &'life2 [Type]
) -> Pin<Box<dyn Future<Output = Result<Statement, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,

Like Client::prepare_typed_cached

fn transaction<'a, 'async_trait>(
    &'a mut self
) -> Pin<Box<dyn Future<Output = Result<Transaction<'a>, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,

Like Client::transaction.

fn batch_execute<'life0, 'life1, 'async_trait>(
    &'life0 self,
    query: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Like Client::batch_execute.