Struct BatchOp 

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

An op joined to the pending batch. Implements AtomicOperation — use it exactly like any atomic operation, then exit with commit or defer.

There is no mutable access to the raw es_entity::DbOp (only a shared Deref view): committing, rolling back, or swapping out the underlying op is unrepresentable, so work and checkpoint can only land together, through the runner.

Implementations

impl<'inv> BatchOp<'inv>

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

Land the whole batch (my work included) when the invocation returns: checkpoint at my sequence → commit.

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

Leave the op open so subsequent events can coalesce into it. The runner lands it when the ready persistent backlog is drained, when the configured max batch size is reached, when a later event commits or isolates, or on shutdown.

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 BatchOp<'_>

Full delegation to the inner es_entity::DbOp — including the provided methods, which es_entity::DbOp overrides (supports_hooks is true, commit_hook returns registered hooks, maybe_now/clock carry the op’s cached time and clock). Inheriting the trait defaults instead would silently report supports_hooks() == false and lose the op time.

This lets handlers pass &mut op directly to any fn(&mut impl AtomicOperation) API (service *_in_op methods, spawn_in_op, publish_persisted_in_op, …) — and it is the only mutable surface: with no DerefMut, a &mut es_entity::DbOp can never be obtained from the guard (which would allow std::mem::swap-ing in a decoy op and committing the real one without its checkpoint).

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<H: CommitHook>(&mut self, hook: H) -> Result<(), H>

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: CommitHook>(&self) -> Option<&H>

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.

fn supports_hooks(&self) -> bool

Whether this operation supports commit hooks.

impl Deref for BatchOp<'_>

type Target = DbOp<'static>

The resulting type after dereferencing.

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

Dereferences the value.