Struct ActivityTx 

pub struct ActivityTx(/* private fields */);

A transaction handle exposed to #[activity] methods as self.tx.

Wraps an active SQL transaction and implements sqlx::Executor for &ActivityTx, so activities can write &self.tx anywhere sqlx expects an executor — just like &self.pool works for sqlx::PgPool.

#[activity]
pub async fn transfer(&self, amount: i64) -> Result<(), ClusterError> {
    sqlx::query("UPDATE accounts SET balance = balance - $1")
        .bind(amount)
        .execute(&self.tx)
        .await?;
    Ok(())
}

The transaction is opened by the activity wrapper before the method runs and committed (with the journal entry) after the method returns.

Implementations

impl ActivityTx

pub fn new(tx: Transaction<'static, Postgres>) -> Self

Create a new ActivityTx wrapping an open transaction.

pub async fn into_inner(self) -> Transaction<'static, Postgres>

Consume this wrapper and return the inner transaction.

Used by the activity wrapper after the method returns to save the journal entry and commit.

Trait Implementations

impl Debug for ActivityTx

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

Formats the value using the given formatter.

impl<'c> Executor<'c> for &'c ActivityTx

type Database = Postgres

fn fetch_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<Either<PgQueryResult, PgRow>, Error>>

where E: Execute<'q, Postgres> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_optional<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Option<PgRow>, Error>>

where E: Execute<'q, Postgres> + 'q, 'c: 'e,

Execute the query and returns at most one row.

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Postgres as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Postgres as Database>::Statement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Statement<'q>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.