Struct CommandTransaction 

pub struct CommandTransaction {
    pub multi: MultiTransaction,
    pub single: SingleTransaction,
    pub cmd: Option<MultiWriteTransaction>,
    pub event_bus: EventBus,
    pub identity: IdentityId,
    /* private fields */
}

An active command transaction that holds a multi command transaction and provides query/command access to single storage.

The transaction will auto-rollback on drop if not explicitly committed.

Fields

multi: MultiTransaction

single: SingleTransaction

cmd: Option<MultiWriteTransaction>

event_bus: EventBus

identity: IdentityId

The identity executing this transaction.

Implementations

impl CommandTransaction

pub fn new( multi: MultiTransaction, single: SingleTransaction, event_bus: EventBus, interceptors: Interceptors, identity: IdentityId, clock: Clock, ) -> Result<Self>

Creates a new active command transaction with a pre-commit callback

pub fn set_executor(&mut self, executor: Arc<dyn RqlExecutor>)

Set the RQL executor for this transaction.

pub fn rql(&mut self, rql: &str, params: Params) -> ExecutionResult

Execute RQL within this transaction using the attached executor.

Panics if no RqlExecutor has been set on this transaction.

pub fn event_bus(&self) -> &EventBus

pub fn commit(&mut self) -> Result<CommitVersion>

Commit the transaction. Since single transactions are short-lived and auto-commit, this only commits the multi transaction.

pub fn execute_bulk_unchecked<F, R>(&mut self, body: F) -> Result<R>

where F: FnOnce(&mut CommandTransaction) -> Result<R>,

Run body with conflict tracking disabled, then commit via the bypass path. This is the only public entry point that reaches commit_unchecked; both halves it composes are crate-private.

On body failure the transaction is rolled back before the error is returned. Without this, the conflict manager remains in its disabled state and a subsequent commit() on the same transaction would register an empty oracle window, silently bypassing SSI conflict detection. rollback resets ConflictManager.disabled so a reused transaction resumes normal tracking.

See the “Unchecked commits” section in multi::transaction for the safety contract.

pub fn rollback(&mut self) -> Result<()>

Rollback the transaction.

pub fn pending_writes(&self) -> &PendingWrites

Get access to the pending writes in this transaction

This allows checking for key conflicts when committing FlowTransactions to ensure they operate on non-overlapping keyspaces.

pub fn with_single_query<'a, I, F, R>(&self, keys: I, f: F) -> Result<R>

where I: IntoIterator<Item = &'a EncodedKey> + Send, F: FnOnce(&mut SingleReadTransaction<'_>) -> Result<R> + Send, R: Send,

Execute a function with query access to the single transaction.

pub fn with_single_command<'a, I, F, R>(&self, keys: I, f: F) -> Result<R>

where I: IntoIterator<Item = &'a EncodedKey> + Send, F: FnOnce(&mut SingleWriteTransaction<'_>) -> Result<R> + Send, R: Send,

Execute a function with query access to the single transaction.

pub fn with_multi_query<F, R>(&self, f: F) -> Result<R>

where F: FnOnce(&mut QueryTransaction) -> Result<R>,

Execute a function with a query transaction view. This creates a new query transaction using the stored multi-version storage. The query transaction will operate independently but share the same single/CDC storage.

pub fn with_multi_query_as_of_exclusive<F, R>( &self, version: CommitVersion, f: F, ) -> Result<R>

where F: FnOnce(&mut QueryTransaction) -> Result<R>,

pub fn with_multi_query_as_of_inclusive<F, R>( &self, version: CommitVersion, f: F, ) -> Result<R>

where F: FnOnce(&mut QueryTransaction) -> Result<R>,

pub fn begin_single_query<'a, I>( &self, keys: I, ) -> Result<SingleReadTransaction<'_>>

where I: IntoIterator<Item = &'a EncodedKey>,

Begin a single-version query transaction for specific keys

pub fn begin_single_command<'a, I>( &self, keys: I, ) -> Result<SingleWriteTransaction<'_>>

where I: IntoIterator<Item = &'a EncodedKey>,

Begin a single-version command transaction for specific keys

pub fn track_row_change(&mut self, change: RowChange)

Track a row change for post-commit event emission

pub fn track_flow_change(&mut self, change: Change)

Track a flow change for transactional view pre-commit processing.

pub fn version(&self) -> CommitVersion

Get the transaction version

pub fn id(&self) -> TransactionId

Get the transaction ID

pub fn get(&mut self, key: &EncodedKey) -> Result<Option<MultiVersionRow>>

Get a value by key

pub fn get_committed( &mut self, key: &EncodedKey, ) -> Result<Option<MultiVersionRow>>

Read the committed value at the transaction’s read version, ignoring pending intra-tx writes.

pub fn contains_key(&mut self, key: &EncodedKey) -> Result<bool>

Check if a key exists

pub fn prefix(&mut self, prefix: &EncodedKey) -> Result<MultiVersionBatch>

Get a prefix batch

pub fn prefix_rev(&mut self, prefix: &EncodedKey) -> Result<MultiVersionBatch>

Get a reverse prefix batch

pub fn read_as_of_version_exclusive( &mut self, version: CommitVersion, ) -> Result<()>

Read as of version exclusive

pub fn set(&mut self, key: &EncodedKey, row: EncodedRow) -> Result<()>

Set a key-value pair

pub fn reserve_writes(&mut self, additional: usize) -> Result<()>

Reserve capacity in the conflict tracker for additional more write keys. Use ahead of a known-size bulk write to avoid HashSet rehash churn.

pub fn unset(&mut self, key: &EncodedKey, row: EncodedRow) -> Result<()>

Unset a key, preserving the deleted values.

The row parameter contains the deleted row for CDC and metrics.

pub fn remove(&mut self, key: &EncodedKey) -> Result<()>

Remove a key without preserving the deleted values.

Use when only the key matters (e.g., index entries, catalog metadata).

pub fn mark_preexisting(&mut self, key: &EncodedKey) -> Result<()>

pub fn range( &mut self, range: EncodedKeyRange, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionRow>> + Send + '_>>

Create a streaming iterator for forward range queries.

pub fn range_rev( &mut self, range: EncodedKeyRange, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionRow>> + Send + '_>>

Create a streaming iterator for reverse range queries.

Trait Implementations

impl Drop for CommandTransaction

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> From<&'a mut CommandTransaction> for Transaction<'a>

fn from(txn: &'a mut CommandTransaction) -> Self

Converts to this type from the input type.

impl WithEventBus for CommandTransaction

fn event_bus(&self) -> &EventBus

impl WithInterceptors for CommandTransaction

fn table_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPreInsertInterceptor + Send + Sync>

fn table_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPostInsertInterceptor + Send + Sync>

fn table_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPreUpdateInterceptor + Send + Sync>

fn table_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPostUpdateInterceptor + Send + Sync>

fn table_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPreDeleteInterceptor + Send + Sync>

fn table_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPostDeleteInterceptor + Send + Sync>

fn ringbuffer_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPreInsertInterceptor + Send + Sync>

fn ringbuffer_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPostInsertInterceptor + Send + Sync>

fn ringbuffer_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPreUpdateInterceptor + Send + Sync>

fn ringbuffer_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPostUpdateInterceptor + Send + Sync>

fn ringbuffer_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPreDeleteInterceptor + Send + Sync>

fn ringbuffer_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPostDeleteInterceptor + Send + Sync>

fn pre_commit_interceptors( &mut self, ) -> &mut Chain<dyn PreCommitInterceptor + Send + Sync>

fn post_commit_interceptors( &mut self, ) -> &mut Chain<dyn PostCommitInterceptor + Send + Sync>

fn namespace_post_create_interceptors( &mut self, ) -> &mut Chain<dyn NamespacePostCreateInterceptor + Send + Sync>

fn namespace_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn NamespacePreUpdateInterceptor + Send + Sync>

fn namespace_post_update_interceptors( &mut self, ) -> &mut Chain<dyn NamespacePostUpdateInterceptor + Send + Sync>

fn namespace_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn NamespacePreDeleteInterceptor + Send + Sync>

fn table_post_create_interceptors( &mut self, ) -> &mut Chain<dyn TablePostCreateInterceptor + Send + Sync>

fn table_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn TablePreUpdateInterceptor + Send + Sync>

fn table_post_update_interceptors( &mut self, ) -> &mut Chain<dyn TablePostUpdateInterceptor + Send + Sync>

fn table_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn TablePreDeleteInterceptor + Send + Sync>

fn view_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn ViewRowPreInsertInterceptor + Send + Sync>

fn view_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn ViewRowPostInsertInterceptor + Send + Sync>

fn view_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn ViewRowPreUpdateInterceptor + Send + Sync>

fn view_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn ViewRowPostUpdateInterceptor + Send + Sync>

fn view_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn ViewRowPreDeleteInterceptor + Send + Sync>

fn view_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn ViewRowPostDeleteInterceptor + Send + Sync>

fn view_post_create_interceptors( &mut self, ) -> &mut Chain<dyn ViewPostCreateInterceptor + Send + Sync>

fn view_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn ViewPreUpdateInterceptor + Send + Sync>

fn view_post_update_interceptors( &mut self, ) -> &mut Chain<dyn ViewPostUpdateInterceptor + Send + Sync>

fn view_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn ViewPreDeleteInterceptor + Send + Sync>

fn ringbuffer_post_create_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPostCreateInterceptor + Send + Sync>

fn ringbuffer_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPreUpdateInterceptor + Send + Sync>

fn ringbuffer_post_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPostUpdateInterceptor + Send + Sync>

fn ringbuffer_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPreDeleteInterceptor + Send + Sync>

fn dictionary_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPreInsertInterceptor + Send + Sync>

fn dictionary_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPostInsertInterceptor + Send + Sync>

fn dictionary_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPreUpdateInterceptor + Send + Sync>

fn dictionary_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPostUpdateInterceptor + Send + Sync>

fn dictionary_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPreDeleteInterceptor + Send + Sync>

fn dictionary_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPostDeleteInterceptor + Send + Sync>

fn dictionary_post_create_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryPostCreateInterceptor + Send + Sync>

fn dictionary_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryPreUpdateInterceptor + Send + Sync>

fn dictionary_post_update_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryPostUpdateInterceptor + Send + Sync>

fn dictionary_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryPreDeleteInterceptor + Send + Sync>

fn series_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPreInsertInterceptor + Send + Sync>

fn series_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPostInsertInterceptor + Send + Sync>

fn series_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPreUpdateInterceptor + Send + Sync>

fn series_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPostUpdateInterceptor + Send + Sync>

fn series_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPreDeleteInterceptor + Send + Sync>

fn series_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPostDeleteInterceptor + Send + Sync>

fn series_post_create_interceptors( &mut self, ) -> &mut Chain<dyn SeriesPostCreateInterceptor + Send + Sync>

fn series_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn SeriesPreUpdateInterceptor + Send + Sync>

fn series_post_update_interceptors( &mut self, ) -> &mut Chain<dyn SeriesPostUpdateInterceptor + Send + Sync>

fn series_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn SeriesPreDeleteInterceptor + Send + Sync>

fn identity_post_create_interceptors( &mut self, ) -> &mut Chain<dyn IdentityPostCreateInterceptor + Send + Sync>

fn identity_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn IdentityPreUpdateInterceptor + Send + Sync>

fn identity_post_update_interceptors( &mut self, ) -> &mut Chain<dyn IdentityPostUpdateInterceptor + Send + Sync>

fn identity_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn IdentityPreDeleteInterceptor + Send + Sync>

fn role_post_create_interceptors( &mut self, ) -> &mut Chain<dyn RolePostCreateInterceptor + Send + Sync>

fn role_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn RolePreUpdateInterceptor + Send + Sync>

fn role_post_update_interceptors( &mut self, ) -> &mut Chain<dyn RolePostUpdateInterceptor + Send + Sync>

fn role_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn RolePreDeleteInterceptor + Send + Sync>

fn granted_role_post_create_interceptors( &mut self, ) -> &mut Chain<dyn GrantedRolePostCreateInterceptor + Send + Sync>

fn granted_role_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn GrantedRolePreDeleteInterceptor + Send + Sync>

fn authentication_post_create_interceptors( &mut self, ) -> &mut Chain<dyn AuthenticationPostCreateInterceptor + Send + Sync>

fn authentication_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn AuthenticationPreDeleteInterceptor + Send + Sync>

impl Write for CommandTransaction

fn set(&mut self, key: &EncodedKey, row: EncodedRow) -> Result<()>

fn unset(&mut self, key: &EncodedKey, row: EncodedRow) -> Result<()>

fn remove(&mut self, key: &EncodedKey) -> Result<()>

fn mark_preexisting(&mut self, key: &EncodedKey) -> Result<()>

fn track_row_change(&mut self, change: RowChange)

Replicas implement this as a no-op (no CDC).

fn track_flow_change(&mut self, change: Change)

Replicas implement this as a no-op (no transactional view processing).