Struct Transactional 

pub struct Transactional;

A subscription whose handler writes through the delivery’s transaction, which acknowledgement commits.

The mount-site step transactional switches a registration to it: the handler then takes the transaction with Ctx<keys::Tx<DB>>.

Examples

use ruststream_sqlx::prelude::*;
use sqlx::{PgPool, Postgres};

#[derive(Inbox, sqlx::FromRow)]
#[inbox(table = "signup_jobs")]
pub struct Signup {
    #[field(id)]
    id: i64,
    #[field(payload)]
    payload: Vec<u8>,
}

#[derive(serde::Deserialize)]
struct Account {
    email: String,
}

#[subscriber(InboxQueue::<Signup>::new("signups"))]
async fn open_account(account: &Account, Ctx(mut tx): Ctx<keys::Tx<Postgres>>) -> HandlerOutcome {
    let opened = sqlx::query("INSERT INTO accounts (email) VALUES ($1)")
        .bind(&account.email)
        .execute(&mut *tx)
        .await;
    if opened.is_ok() { HandlerOutcome::ack() } else { HandlerOutcome::retry() }
}

pub fn app(pool: PgPool) -> RustStream {
    RustStream::new(AppInfo::new("accounts", "0.1.0")).with_broker(SqlxBroker::new(pool), |b| {
        // The registration's `InboxQueue<Signup, Plain>` becomes
        // `InboxQueue<Signup, Transactional>`.
        b.include(open_account.transactional());
    })
}

Trait Implementations

impl Clone for Transactional

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Transactional

impl Debug for Transactional

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

Formats the value using the given formatter.

impl Default for Transactional

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Transactional

impl Hash for Transactional

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Transactional

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Transactional