Struct StandardCommandTransaction 

pub struct StandardCommandTransaction {
    pub multi: TransactionMultiVersion,
    pub single: TransactionSingle,
    /* 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: TransactionMultiVersion

single: TransactionSingle

Implementations

impl StandardCommandTransaction

pub async fn new( multi: TransactionMultiVersion, single: TransactionSingle, cdc: TransactionCdc, event_bus: EventBus, catalog: MaterializedCatalog, interceptors: Interceptors<Self>, ) -> Result<Self>

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

pub fn event_bus(&self) -> &EventBus

pub async 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 cdc(&self) -> &TransactionCdc

Get access to the CDC transaction interface

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 async 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 <TransactionSingle as SingleVersionTransaction>::Query<'_>) -> Result<R> + Send, R: Send,

Execute a function with query access to the single transaction.

pub async 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 <TransactionSingle as SingleVersionTransaction>::Command<'_>) -> Result<R> + Send, R: Send,

Execute a function with query access to the single transaction.

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

where F: FnOnce(&mut StandardQueryTransaction) -> 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 async fn with_multi_query_as_of_exclusive<F, R>( &self, version: CommitVersion, f: F, ) -> Result<R>

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

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

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

Trait Implementations

impl CatalogTrackDictionaryChangeOperations for StandardCommandTransaction

fn track_dictionary_def_created( &mut self, dictionary: DictionaryDef, ) -> Result<()>

fn track_dictionary_def_updated( &mut self, pre: DictionaryDef, post: DictionaryDef, ) -> Result<()>

fn track_dictionary_def_deleted( &mut self, dictionary: DictionaryDef, ) -> Result<()>

impl CatalogTrackFlowChangeOperations for StandardCommandTransaction

fn track_flow_def_created(&mut self, flow: FlowDef) -> Result<()>

fn track_flow_def_updated(&mut self, pre: FlowDef, post: FlowDef) -> Result<()>

fn track_flow_def_deleted(&mut self, flow: FlowDef) -> Result<()>

impl CatalogTrackNamespaceChangeOperations for StandardCommandTransaction

fn track_namespace_def_created(&mut self, namespace: NamespaceDef) -> Result<()>

fn track_namespace_def_updated( &mut self, pre: NamespaceDef, post: NamespaceDef, ) -> Result<()>

fn track_namespace_def_deleted(&mut self, namespace: NamespaceDef) -> Result<()>

impl CatalogTrackRingBufferChangeOperations for StandardCommandTransaction

fn track_ringbuffer_def_created( &mut self, ringbuffer: RingBufferDef, ) -> Result<()>

fn track_ringbuffer_def_updated( &mut self, pre: RingBufferDef, post: RingBufferDef, ) -> Result<()>

fn track_ringbuffer_def_deleted( &mut self, ringbuffer: RingBufferDef, ) -> Result<()>

impl CatalogTrackTableChangeOperations for StandardCommandTransaction

fn track_table_def_created(&mut self, table: TableDef) -> Result<()>

fn track_table_def_updated( &mut self, pre: TableDef, post: TableDef, ) -> Result<()>

fn track_table_def_deleted(&mut self, table: TableDef) -> Result<()>

impl CatalogTrackViewChangeOperations for StandardCommandTransaction

fn track_view_def_created(&mut self, view: ViewDef) -> Result<()>

fn track_view_def_updated(&mut self, pre: ViewDef, post: ViewDef) -> Result<()>

fn track_view_def_deleted(&mut self, view: ViewDef) -> Result<()>

impl CommandTransaction for StandardCommandTransaction

type SingleVersionCommand<'a> = <TransactionSingle as SingleVersionTransaction>::Command<'a>

fn begin_single_command<'a, 'life0, 'async_trait, I>( &'life0 self, keys: I, ) -> Pin<Box<dyn Future<Output = Result<Self::SingleVersionCommand<'_>>> + Send + 'async_trait>>

where I: IntoIterator<Item = &'a EncodedKey> + Send + 'async_trait, Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

fn get_changes(&self) -> &TransactionalDefChanges

Get reference to catalog changes for this transaction

impl Drop for StandardCommandTransaction

fn drop(&mut self)

Executes the destructor for this type.

impl ExecuteCommand<StandardCommandTransaction> for Executor

fn execute_command<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, txn: &'life1 mut StandardCommandTransaction, cmd: Command<'life2>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Frame>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl ExecuteCommand<StandardCommandTransaction> for StandardEngine

fn execute_command<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, txn: &'life1 mut StandardCommandTransaction, cmd: Command<'life2>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Frame>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl<'a> From<&'a mut StandardCommandTransaction> for StandardTransaction<'a>

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

Converts to this type from the input type.

impl MaterializedCatalogTransaction for StandardCommandTransaction

fn catalog(&self) -> &MaterializedCatalog

impl MultiVersionCommandTransaction for StandardCommandTransaction

fn set<'life0, 'life1, 'async_trait>( &'life0 mut self, key: &'life1 EncodedKey, row: EncodedValues, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn remove<'life0, 'life1, 'async_trait>( &'life0 mut self, key: &'life1 EncodedKey, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn commit<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<CommitVersion>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn rollback<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl MultiVersionQueryTransaction for StandardCommandTransaction

fn version(&self) -> CommitVersion

fn id(&self) -> TransactionId

fn get<'life0, 'life1, 'async_trait>( &'life0 mut self, key: &'life1 EncodedKey, ) -> Pin<Box<dyn Future<Output = Result<Option<MultiVersionValues>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn contains_key<'life0, 'life1, 'async_trait>( &'life0 mut self, key: &'life1 EncodedKey, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn range_batch<'life0, 'async_trait>( &'life0 mut self, range: EncodedKeyRange, batch_size: u64, ) -> Pin<Box<dyn Future<Output = Result<MultiVersionBatch>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn range_rev_batch<'life0, 'async_trait>( &'life0 mut self, range: EncodedKeyRange, batch_size: u64, ) -> Pin<Box<dyn Future<Output = Result<MultiVersionBatch>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn read_as_of_version_exclusive<'life0, 'async_trait>( &'life0 mut self, version: CommitVersion, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn range<'life0, 'async_trait>( &'life0 mut self, range: EncodedKeyRange, ) -> Pin<Box<dyn Future<Output = Result<MultiVersionBatch, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn range_rev<'life0, 'async_trait>( &'life0 mut self, range: EncodedKeyRange, ) -> Pin<Box<dyn Future<Output = Result<MultiVersionBatch, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn prefix<'life0, 'life1, 'async_trait>( &'life0 mut self, prefix: &'life1 EncodedKey, ) -> Pin<Box<dyn Future<Output = Result<MultiVersionBatch, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn prefix_rev<'life0, 'life1, 'async_trait>( &'life0 mut self, prefix: &'life1 EncodedKey, ) -> Pin<Box<dyn Future<Output = Result<MultiVersionBatch, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn read_as_of_version_inclusive<'life0, 'async_trait>( &'life0 mut self, version: CommitVersion, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

impl QueryTransaction for StandardCommandTransaction

type SingleVersionQuery<'a> = <TransactionSingle as SingleVersionTransaction>::Query<'a>

type CdcQuery<'a> = <TransactionCdc as CdcTransaction>::Query<'a>

fn begin_single_query<'a, 'life0, 'async_trait, I>( &'life0 self, keys: I, ) -> Pin<Box<dyn Future<Output = Result<Self::SingleVersionQuery<'_>>> + Send + 'async_trait>>

where I: IntoIterator<Item = &'a EncodedKey> + Send + 'async_trait, Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

fn begin_cdc_query<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Self::CdcQuery<'_>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl TransactionalDictionaryChanges for StandardCommandTransaction

fn find_dictionary(&self, id: DictionaryId) -> Option<&DictionaryDef>

fn find_dictionary_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&DictionaryDef>

fn is_dictionary_deleted(&self, id: DictionaryId) -> bool

fn is_dictionary_deleted_by_name( &self, namespace: NamespaceId, name: &str, ) -> bool

impl TransactionalFlowChanges for StandardCommandTransaction

fn find_flow(&self, id: FlowId) -> Option<&FlowDef>

fn find_flow_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&FlowDef>

fn is_flow_deleted(&self, id: FlowId) -> bool

fn is_flow_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalNamespaceChanges for StandardCommandTransaction

fn find_namespace(&self, id: NamespaceId) -> Option<&NamespaceDef>

fn find_namespace_by_name(&self, name: &str) -> Option<&NamespaceDef>

fn is_namespace_deleted(&self, id: NamespaceId) -> bool

fn is_namespace_deleted_by_name(&self, name: &str) -> bool

impl TransactionalRingBufferChanges for StandardCommandTransaction

fn find_ringbuffer(&self, id: RingBufferId) -> Option<&RingBufferDef>

fn find_ringbuffer_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&RingBufferDef>

fn is_ringbuffer_deleted(&self, id: RingBufferId) -> bool

fn is_ringbuffer_deleted_by_name( &self, namespace: NamespaceId, name: &str, ) -> bool

impl TransactionalTableChanges for StandardCommandTransaction

fn find_table(&self, id: TableId) -> Option<&TableDef>

fn find_table_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&TableDef>

fn is_table_deleted(&self, id: TableId) -> bool

fn is_table_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalViewChanges for StandardCommandTransaction

fn find_view(&self, id: ViewId) -> Option<&ViewDef>

fn find_view_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&ViewDef>

fn is_view_deleted(&self, id: ViewId) -> bool

fn is_view_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl WithEventBus for StandardCommandTransaction

fn event_bus(&self) -> &EventBus

impl WithInterceptors<StandardCommandTransaction> for StandardCommandTransaction

fn table_pre_insert_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn TablePreInsertInterceptor<StandardCommandTransaction> + Send + Sync>

Access table pre-insert interceptor chain

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

Access table post-insert interceptor chain

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

Access table pre-update interceptor chain

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

Access table post-update interceptor chain

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

Access table pre-delete interceptor chain

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

Access table post-delete interceptor chain

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

Access ring buffer pre-insert interceptor chain

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

Access ring buffer post-insert interceptor chain

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

Access ring buffer pre-update interceptor chain

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

Access ring buffer post-update interceptor chain

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

Access ring buffer pre-delete interceptor chain

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

Access ring buffer post-delete interceptor chain

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

Access pre-commit interceptor chain

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

Access post-commit interceptor chain

fn namespace_def_post_create_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn NamespaceDefPostCreateInterceptor<StandardCommandTransaction> + Send + Sync>

Access namespace post-create interceptor chain

fn namespace_def_pre_update_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn NamespaceDefPreUpdateInterceptor<StandardCommandTransaction> + Send + Sync>

Access namespace pre-update interceptor chain

fn namespace_def_post_update_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn NamespaceDefPostUpdateInterceptor<StandardCommandTransaction> + Send + Sync>

Access namespace post-update interceptor chain

fn namespace_def_pre_delete_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn NamespaceDefPreDeleteInterceptor<StandardCommandTransaction> + Send + Sync>

Access namespace pre-delete interceptor chain

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

Access table definition post-create interceptor chain

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

Access table definition pre-update interceptor chain

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

Access table definition post-update interceptor chain

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

Access table definition pre-delete interceptor chain

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

Access view post-create interceptor chain

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

Access view pre-update interceptor chain

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

Access view post-update interceptor chain

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

Access view pre-delete interceptor chain

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

Access ring buffer definition post-create interceptor chain

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

Access ring buffer definition pre-update interceptor chain

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

Access ring buffer definition post-update interceptor chain

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

Access ring buffer definition pre-delete interceptor chain

impl Execute<StandardCommandTransaction, StandardQueryTransaction> for Executor

impl TransactionalChanges for StandardCommandTransaction