Struct EmbeddedTransactor 

pub struct EmbeddedTransactor { /* private fields */ }

A serialized, in-process transactor. The log append is the commit point.

Implementations

impl EmbeddedTransactor

pub fn recover( schema: Schema, log: Arc<dyn TransactionLog>, ) -> Result<Self, TransactError>

Recovers a transactor by replaying the durable log exactly once.

Errors

Returns an error when the durable log cannot be replayed.

pub fn recover_from( base: Db, log: Arc<dyn TransactionLog>, ) -> Result<Self, TransactError>

Recovers from an empty base database value (schema plus naming) by replaying the durable log exactly once.

Errors

Returns an error when the durable log cannot be replayed.

pub async fn recover_from_async( base: Db, log: Arc<dyn TransactionLog>, ) -> Result<Self, TransactError>

Recovers a transactor through the log’s asynchronous storage path.

Errors

Returns an error when the durable log cannot be replayed.

pub fn recover_from_snapshot( snapshot: Db, next_entity_id: u64, last_tx_instant: i64, log: Arc<dyn TransactionLog>, ) -> Result<Self, TransactError>

Recovers from a published current-state snapshot plus the log tail, replaying only transactions after the snapshot’s basis instead of the whole history — so open and restart cost scale with the tail, not the database’s age.

snapshot is the current value at snapshot.basis_t() (typically Db::from_current_snapshot materialized from the published EAVT index). next_entity_id and last_tx_instant are the allocator and transaction-time high-water marks recorded in the DbRoot at publication (DbRoot::next_entity_id / DbRoot::last_tx_instant); they carry the state a current-facts snapshot cannot: entities fully retracted before the snapshot (whose ids must not be reused) and the last commit’s instant (for :db/txInstant monotonicity when the tail is empty). Both are combined by max with whatever the replayed tail reveals, so an over-estimate is safe and a stale hint can only make allocation more conservative.

The caller is responsible for opening log at the same lease version it recovered the snapshot under, exactly as recover_from requires.

Errors

Returns an error when the log tail cannot be replayed.

pub async fn recover_from_snapshot_async( snapshot: Db, next_entity_id: u64, last_tx_instant: i64, log: Arc<dyn TransactionLog>, ) -> Result<Self, TransactError>

Recovers from a published snapshot plus an asynchronously read log tail.

Errors

Returns an error when the log tail cannot be replayed.

pub fn db(&self) -> Db

Returns the current immutable database value.

pub fn subscribe(&self) -> Receiver<TxReport>

Subscribes to reports for transactions committed after this call.

pub fn transact( &self, items: impl IntoIterator<Item = TxItem>, ) -> Result<TxReport, TransactError>

Validates, durably appends, applies, and reports a transaction.

Errors

Returns an error for rejected transaction data, clock failure, or when the durable append fails. No report is sent on error.

pub async fn transact_async( &self, items: impl IntoIterator<Item = TxItem>, ) -> Result<TxReport, TransactError>

Validates under a short state lock, awaits durability without holding that lock, then atomically publishes the durable transaction in memory. Async calls are serialized here so standalone callers have the same single-writer guarantee as node-hosted callers.

Errors

Returns an error for rejected transaction data, clock failure, or when the durable append fails. No report is sent on error.

pub fn batch_cursor(&self) -> BatchCursor

Snapshots the live value and allocation watermarks for preparing a group-commit batch. The returned BatchCursor evolves privately; Self::install_batch publishes it after the batch is durable.

pub fn install_batch( &self, cursor: BatchCursor, prepared: Vec<Prepared>, ) -> Vec<TxReport>

Publishes a durably-committed batch: installs the cursor’s value as the live value, advances the allocation and transaction-time watermarks, fans the reports out to subscribers, and returns them in batch order. The caller must have made every record in prepared durable and verified ownership first. The cursor was snapshotted from, and advanced past, the live value under the same single-writer serialization, so installing it cannot lose a concurrent commit.

pub fn update_naming(&self, idents: Idents, interner: KeywordInterner)

Replaces the ident/keyword naming attached to the current database value (used when the boundary interns new keywords).

pub async fn publish_indexes( &self, store: &(impl BlobStore + RootStore), root_name: &str, lease_version: u64, ) -> Result<DbRoot, TransactError>

Builds a consistent snapshot of all four indexes and publishes their blob ids.

Each index is chunked into content-defined leaf blobs under a manifest blob (corium_store::chunk_segment_keys), and only chunks absent from the store are uploaded — consecutive publications share every unchanged chunk, so a small change re-uploads a few chunks instead of the whole index.

Blobs are uploaded before the root CAS. Transactions may continue while the immutable snapshot is encoded; a later run indexes any remaining log tail.

Publication is fenced by lease_version and monotone in index_basis_t: a root already published under a newer lease version deposes this writer (TransactError::Deposed); a root at an equal or newer basis (or one that wins a concurrent CAS race) leaves this snapshot’s blobs for garbage collection. The freshly built root is returned when it, or a newer basis, is installed.

Errors

Returns an error if a blob upload, root read, or fenced publication fails.