Struct SavepointOp 

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

An AtomicOperation scoped to a database SAVEPOINT inside a parent DbOp.

Created by DbOp::with_savepoint / DbOp::begin_savepoint. 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.

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.
• 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. They run once, at the parent’s 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 parent 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.

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

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 parent transaction 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 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 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 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 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.