Struct DbOp 

pub struct DbOp<'c> { /* private fields */ }

Default return type of the derived EsRepo::begin_op().

Used as a wrapper of a sqlx::Transaction but can also cache the time at which the transaction is taking place.

When a manual clock is provided, the transaction will automatically cache that clock’s time, enabling deterministic testing. This cached time will be used in all time-dependent operations.

Implementations

impl<'c> DbOp<'c>

pub async fn init(pool: &Pool) -> Result<DbOp<'static>, Error>

Initializes a transaction using the global clock.

Delegates to init_with_clock using the global clock handle.

pub async fn init_with_clock( pool: &Pool, clock: &ClockHandle, ) -> Result<DbOp<'static>, Error>

Initializes a transaction with the specified clock.

If the clock is manual, its current time will be cached in the transaction.

pub fn with_time(self, time: DateTime<Utc>) -> DbOpWithTime<'c>

Transitions to a DbOpWithTime with the given time cached.

pub fn with_clock_time(self) -> DbOpWithTime<'c>

Transitions to a DbOpWithTime using the clock.

Uses cached time if present, otherwise uses the clock’s current time.

pub async fn with_db_time(self) -> Result<DbOpWithTime<'c>, Error>

Transitions to a DbOpWithTime using the database time.

Priority order:

1. Cached time if present
2. Manual clock time if the clock is manual
3. Database time via SELECT NOW()

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

Returns the optionally cached chrono::DateTime

pub async fn begin(&mut self) -> Result<DbOp<'_>, Error>

Begins a nested transaction.

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

Commits the inner transaction.

pub fn tx_mut(&mut self) -> &mut Transaction<'c, Db>

Gets a mutable handle to the inner transaction

Trait Implementations

impl<'o> AtomicOperation for DbOp<'o>

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 as_executor(&mut self) -> &mut Connection

Returns the sqlx::Executor implementation. 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.