Struct CommandTransaction 

pub struct CommandTransaction {
    pub multi: MultiTransaction,
    pub single: SingleTransaction,
    pub cmd: Option<MultiWriteTransaction>,
    pub event_bus: EventBus,
    pub testing: Option<TestingContext>,
    /* 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

testing: Option<TestingContext>

Testing audit log. Set by the VM when in test context.

Implementations

impl CommandTransaction

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

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

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 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<MultiVersionValues>>

Get a value by key

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: EncodedValues) -> Result<()>

Set a key-value pair

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

Unset a key, preserving the deleted values.

The values parameter contains the deleted values 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 range( &mut self, range: EncodedKeyRange, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionValues>> + 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<MultiVersionValues>> + 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_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn TablePreInsertInterceptor + Send + Sync>

Access table pre-insert interceptor chain

fn table_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn TablePostInsertInterceptor + Send + Sync>

Access table post-insert interceptor chain

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

Access table pre-update interceptor chain

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

Access table post-update interceptor chain

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

Access table pre-delete interceptor chain

fn table_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn TablePostDeleteInterceptor + Send + Sync>

Access table post-delete interceptor chain

fn ringbuffer_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPreInsertInterceptor + Send + Sync>

Access ring buffer pre-insert interceptor chain

fn ringbuffer_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPostInsertInterceptor + Send + Sync>

Access ring buffer post-insert interceptor chain

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

Access ring buffer pre-update interceptor chain

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

Access ring buffer post-update interceptor chain

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

Access ring buffer pre-delete interceptor chain

fn ringbuffer_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPostDeleteInterceptor + Send + Sync>

Access ring buffer post-delete interceptor chain

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

Access pre-commit interceptor chain

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

Access post-commit interceptor chain

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

Access namespace post-create interceptor chain

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

Access namespace pre-update interceptor chain

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

Access namespace post-update interceptor chain

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

Access namespace pre-delete interceptor chain

fn table_def_post_create_interceptors( &mut self, ) -> &mut Chain<dyn TableDefPostCreateInterceptor + Send + Sync>

Access table definition post-create interceptor chain

fn table_def_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn TableDefPreUpdateInterceptor + Send + Sync>

Access table definition pre-update interceptor chain

fn table_def_post_update_interceptors( &mut self, ) -> &mut Chain<dyn TableDefPostUpdateInterceptor + Send + Sync>

Access table definition post-update interceptor chain

fn table_def_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn TableDefPreDeleteInterceptor + Send + Sync>

Access table definition pre-delete interceptor chain

fn view_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn ViewPreInsertInterceptor + Send + Sync>

Access view pre-insert interceptor chain

fn view_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn ViewPostInsertInterceptor + Send + Sync>

Access view post-insert interceptor chain

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

Access view pre-update interceptor chain

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

Access view post-update interceptor chain

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

Access view pre-delete interceptor chain

fn view_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn ViewPostDeleteInterceptor + Send + Sync>

Access view post-delete interceptor chain

fn view_def_post_create_interceptors( &mut self, ) -> &mut Chain<dyn ViewDefPostCreateInterceptor + Send + Sync>

Access view post-create interceptor chain

fn view_def_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn ViewDefPreUpdateInterceptor + Send + Sync>

Access view pre-update interceptor chain

fn view_def_post_update_interceptors( &mut self, ) -> &mut Chain<dyn ViewDefPostUpdateInterceptor + Send + Sync>

Access view post-update interceptor chain

fn view_def_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn ViewDefPreDeleteInterceptor + Send + Sync>

Access view pre-delete interceptor chain

fn ringbuffer_def_post_create_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferDefPostCreateInterceptor + Send + Sync>

Access ring buffer definition post-create interceptor chain

fn ringbuffer_def_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferDefPreUpdateInterceptor + Send + Sync>

Access ring buffer definition pre-update interceptor chain

fn ringbuffer_def_post_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferDefPostUpdateInterceptor + Send + Sync>

Access ring buffer definition post-update interceptor chain

fn ringbuffer_def_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferDefPreDeleteInterceptor + Send + Sync>

Access ring buffer definition pre-delete interceptor chain