Struct StagedOp 

pub struct StagedOp<'inv> { /* private fields */ }

One stage of a keyed subscriber’s processing of one event: an open op, whose work lands whichever exit is taken.

Implements AtomicOperation — use it like any atomic operation, then take exactly one exit:

exit	meaning	cursor
commit	processing of this event is done	advances past the event
suspend	this stage is done, the chain continues	unmoved
pause_until	this stage is done, processing pauses until at	unmoved

The verbs are about the event, not the transaction: every exit lands this stage’s writes, and what differs is what happens to the cursor. commit means what IsolatedOp::commit means — work and checkpoint land together — so a keyed subscriber that never stages reads exactly like a singleton one: consume, work, commit. suspend and pause_until land the work and leave the checkpoint where it was.

As with IsolatedOp, there is no mutable access to the raw es_entity::DbOp — the op can only land through one of the exits, so no stage can commit without the runner knowing what it meant.

Sealed to its invocation by the same brand Handled carries, so a staged op cannot be stashed and resumed from a later event:

use obix::StagedOp;

struct Evil {
    stash: std::sync::Mutex<Option<StagedOp<'static>>>,
}

async fn stash_it(op: StagedOp<'_>, evil: &Evil) {
    // error[E0521]: borrowed data escapes outside of function
    *evil.stash.lock().unwrap() = Some(op);
}

Implementations

impl<'inv> StagedOp<'inv>

pub async fn suspend( self, ) -> Result<Suspended<'inv>, Box<dyn Error + Send + Sync>>

This stage is done, the event is not: the returned Suspended holds no open transaction, so the subscriber can await external I/O before resume opens the next stage’s op.

The cursor does not move — this event is still being processed, and a crash here replays it (with everything this stage committed already durable).

pub fn pause_until(self, at: DateTime<Utc>) -> Handled<'inv>

This stage is done and processing pauses, with the cursor still parked before this event, until at.

The op’s work lands, but the checkpoint the runner folds in is still pre-this-event: the next run re-reads the event and re-evaluates. The resume time is domain knowledge (a retry schedule owned by the consumer’s entities) — the one fact obix cannot derive.

pub fn commit(self) -> Handled<'inv>

Processing of this event is done: the runner folds the checkpoint at this event’s sequence into the same transaction, so work and cursor advance together — what IsolatedOp::commit does for a singleton.

Methods from Deref<Target = DbOp<'static>>

pub fn maybe_now(&self) -> Option<DateTime<Utc>>

Returns the optionally cached chrono::DateTime

Trait Implementations

impl AtomicOperation for StagedOp<'_>

fn maybe_now(&self) -> Option<DateTime<Utc>>

Function for querying when the operation is taking place - if it is cached.

fn clock(&self) -> &ClockHandle

Returns the clock handle for time operations.

fn connection(&mut self) -> &mut Connection

Returns the raw underlying connection. The desired way to represent this would actually be as a GAT:

fn as_executor(&mut self) -> OneTimeExecutor<'_, &mut Connection>

Returns the sqlx::Executor implementation that statements should be executed through.

fn add_commit_hook_dyn( &mut self, type_id: TypeId, hook: Box<dyn DynHook>, ) -> Result<(), Box<dyn DynHook>>

Object-safe, type-erased form of add_commit_hook.

fn commit_hook_dyn(&self, type_id: TypeId) -> Option<&dyn DynHook>

Object-safe, type-erased form of commit_hook.

fn supports_hooks(&self) -> bool

Whether this operation supports commit hooks.

fn savepoint_parts(&mut self) -> (&mut Connection, HookSlot<'_>)

Simultaneous access to the connection and the commit-hook buffer a nested SAVEPOINT folds into when released. Implementing this is the only thing an operation must do to get the whole of SavepointOperation — with_savepoint, begin_savepoint, and arbitrary-depth nesting — for free.

fn add_commit_hook<H>(&mut self, hook: H) -> Result<(), H>

where H: CommitHook, Self: Sized,

Registers a commit hook that will run pre_commit before and post_commit after the transaction commits. Returns Ok(()) if the hook was registered, Err(hook) if hooks are not supported.

fn commit_hook<H>(&self) -> Option<&H>

where H: CommitHook, Self: Sized,

Typed shared access to the currently-accumulating commit hook of type H, if this operation supports commit hooks and one is registered. Returns the hook a subsequent add_commit_hook::<H> call would merge into.

impl Deref for StagedOp<'_>

type Target = DbOp<'static>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.