Struct SavepointOp 

pub struct SavepointOp<'t> { /* private fields */ }

An AtomicOperation scoped to a database SAVEPOINT inside a parent DbOp or another SavepointOp.

Created by SavepointOperation::with_savepoint / SavepointOperation::begin_savepoint on any operation — including on another SavepointOp, which is how savepoints nest. Statements executed through it run inside the savepoint, so they can be undone with rollback without poisoning — or ending — the parent transaction. This is what makes a “loop over N items in one transaction, but isolate each item’s failure” pattern possible: one COMMIT (one WAL flush) for the whole batch, while a failing item unwinds only its own writes. Nesting extends this to per-sub-item isolation within an already-isolated item, without giving up any of the outer batch’s atomicity.

Hooks are staged, not executed

Commit hooks registered on a SavepointOp — including the ones repositories register internally, e.g. via post_persist_hook — are staged in a private buffer rather than added to the parent operation:

• release issues RELEASE SAVEPOINT and then folds the staged hooks into the parent’s buffer through the ordinary registration/merge path, exactly as if they had been registered on the parent directly. For a nested savepoint the “parent” is the enclosing SavepointOp’s own staged buffer — folding there is not yet visible to its parent until it, too, is released.
• rollback issues ROLLBACK TO SAVEPOINT and drops the staged hooks. A rolled-back item therefore contributes zero hook state to match its zero database state — no phantom event publishes, no inserts referencing rows that no longer exist.

No hook’s pre_commit / post_commit ever runs at savepoint boundaries, nested or not. They run once, at the root commit, over the final merged hook set — so post_commit still only fires after a durable COMMIT, and on_rollback still only fires when the whole transaction is gone.

Implementations

impl<'t> SavepointOp<'t>

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

Releases the savepoint, keeping this scope’s work.

Issues RELEASE SAVEPOINT, then folds the staged commit hooks into the enclosing operation’s buffer via the normal registration/merge path — so a mergeable hook type accumulates across savepoints exactly as it would have on the parent, and a non-mergeable one lands at its own position in release order. For a nested savepoint this is its parent SavepointOp’s staged buffer, not necessarily the root DbOp — a further release (or rollback) up the chain is what makes the fold visible further out.

If the RELEASE itself fails the staged hooks are dropped and the error is returned: the enclosing transaction is in an indeterminate state and the caller must abandon it rather than commit or release further.

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

Rolls back to the savepoint, discarding this scope’s work.

Issues ROLLBACK TO SAVEPOINT and drops the staged commit hooks. The enclosing operation stays alive and usable — including after an error that would otherwise have poisoned it.

Dropping a SavepointOp without calling either release or rollback has the same database effect (sqlx queues the rollback on the connection) and likewise discards the staged hooks.

Trait Implementations

impl AtomicOperation for SavepointOp<'_>

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

Refuses, like any other operation, when the enclosing chain ultimately has nowhere to fold hooks — a savepoint over a bare sqlx::Transaction or any op that returned HookSlot::unsupported, or one nested under a HookOperation on the force_execute_pre_commit path.

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

Reads the staged buffer first, falling back to the parent’s.

While a savepoint is open the two are not yet merged, so a hook type present in both reports only the staged instance here — they become one hook when the savepoint is released.

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

Nesting: an inner savepoint folds into this savepoint’s staged buffer, not straight into the root, so an N-deep chain rolls up one level at a time. tx, staged and parent_hooks are disjoint fields, so the reads and borrows below coexist — the split that the trait boundary could not otherwise express.

Hook capability is propagated, not assumed: this savepoint offers its staged buffer to an inner savepoint only if its own chain can ultimately receive hooks. Handing the buffer over unconditionally would let an inner savepoint accept a hook that had nowhere to go, so add_commit_hook would report success for work whose pre_commit/post_commit could never run.

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 supports_hooks(&self) -> bool

Whether this operation supports commit hooks.

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

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