Struct StandardCommandTransaction 

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

Implementations

impl StandardCommandTransaction

pub fn new( multi: TransactionMultiVersion, single: TransactionSingleVersion, 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 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 fn with_single_query<'a, I, F, R>(&self, keys: I, f: F) -> Result<R>

where I: IntoIterator<Item = &'a EncodedKey>, F: FnOnce(&mut <TransactionSingleVersion as SingleVersionTransaction>::Query<'_>) -> Result<R>,

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>, F: FnOnce(&mut <TransactionSingleVersion as SingleVersionTransaction>::Command<'_>) -> Result<R>,

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

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

pub 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_ring_buffer_def_created( &mut self, ring_buffer: RingBufferDef, ) -> Result<()>

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

fn track_ring_buffer_def_deleted( &mut self, ring_buffer: 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> = <TransactionSingleVersion as SingleVersionTransaction>::Command<'a>

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

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

fn get_changes(&self) -> &TransactionalDefChanges

Get reference to catalog changes for this transaction

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

where I: IntoIterator<Item = &'a EncodedKey>, F: FnOnce(&mut Self::SingleVersionCommand<'_>) -> Result<R, Error>,

impl Drop for StandardCommandTransaction

fn drop(&mut self)

Executes the destructor for this type.

impl ExecuteCommand<StandardCommandTransaction> for Executor

fn execute_command( &self, txn: &mut StandardCommandTransaction, cmd: Command<'_>, ) -> Result<Vec<Frame>>

impl ExecuteCommand<StandardCommandTransaction> for StandardEngine

fn execute_command( &self, txn: &mut StandardCommandTransaction, cmd: Command<'_>, ) -> Result<Vec<Frame>>

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(&mut self, key: &EncodedKey, row: EncodedValues) -> Result<()>

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

fn commit(self) -> Result<CommitVersion>

fn rollback(self) -> Result<()>

impl MultiVersionQueryTransaction for StandardCommandTransaction

fn version(&self) -> CommitVersion

fn id(&self) -> TransactionId

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

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

fn range_batched( &mut self, range: EncodedKeyRange, batch_size: u64, ) -> Result<BoxedMultiVersionIter<'_>>

fn range_rev_batched( &mut self, range: EncodedKeyRange, batch_size: u64, ) -> Result<BoxedMultiVersionIter<'_>>

fn prefix(&mut self, prefix: &EncodedKey) -> Result<BoxedMultiVersionIter<'_>>

fn prefix_rev( &mut self, prefix: &EncodedKey, ) -> Result<BoxedMultiVersionIter<'_>>

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

fn range( &mut self, range: EncodedKeyRange, ) -> Result<Box<dyn Iterator<Item = MultiVersionValues> + Send + '_>, Error>

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

fn read_as_of_version_inclusive( &mut self, version: CommitVersion, ) -> Result<(), Error>

impl QueryTransaction for StandardCommandTransaction

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

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

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

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

fn begin_cdc_query(&self) -> Result<Self::CdcQuery<'_>>

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

where I: IntoIterator<Item = &'a EncodedKey>, F: FnOnce(&mut Self::SingleVersionQuery<'_>) -> Result<R, Error>,

fn with_cdc_query<F, R>(&self, f: F) -> Result<R, Error>

where F: FnOnce(&mut Self::CdcQuery<'_>) -> Result<R, Error>,

impl TransactionalDictionaryChanges for StandardCommandTransaction

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

fn find_dictionary_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> Option<&DictionaryDef>

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

fn is_dictionary_deleted_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> bool

impl TransactionalFlowChanges for StandardCommandTransaction

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

fn find_flow_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> Option<&FlowDef>

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

fn is_flow_deleted_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> bool

impl TransactionalNamespaceChanges for StandardCommandTransaction

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

fn find_namespace_by_name<'a>( &self, name: impl IntoFragment<'a>, ) -> Option<&NamespaceDef>

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

fn is_namespace_deleted_by_name<'a>(&self, name: impl IntoFragment<'a>) -> bool

impl TransactionalRingBufferChanges for StandardCommandTransaction

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

fn find_ring_buffer_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> Option<&RingBufferDef>

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

fn is_ring_buffer_deleted_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> bool

impl TransactionalTableChanges for StandardCommandTransaction

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

fn find_table_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> Option<&TableDef>

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

fn is_table_deleted_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> bool

impl TransactionalViewChanges for StandardCommandTransaction

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

fn find_view_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> Option<&ViewDef>

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

fn is_view_deleted_by_name<'a>( &self, namespace: NamespaceId, name: impl IntoFragment<'a>, ) -> 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>>

Access table pre-insert interceptor chain

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

Access table post-insert interceptor chain

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

Access table pre-update interceptor chain

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

Access table post-update interceptor chain

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

Access table pre-delete interceptor chain

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

Access table post-delete interceptor chain

fn ring_buffer_pre_insert_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferPreInsertInterceptor<StandardCommandTransaction>>

Access ring buffer pre-insert interceptor chain

fn ring_buffer_post_insert_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferPostInsertInterceptor<StandardCommandTransaction>>

Access ring buffer post-insert interceptor chain

fn ring_buffer_pre_update_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferPreUpdateInterceptor<StandardCommandTransaction>>

Access ring buffer pre-update interceptor chain

fn ring_buffer_post_update_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferPostUpdateInterceptor<StandardCommandTransaction>>

Access ring buffer post-update interceptor chain

fn ring_buffer_pre_delete_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferPreDeleteInterceptor<StandardCommandTransaction>>

Access ring buffer pre-delete interceptor chain

fn ring_buffer_post_delete_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferPostDeleteInterceptor<StandardCommandTransaction>>

Access ring buffer post-delete interceptor chain

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

Access pre-commit interceptor chain

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

Access post-commit interceptor chain

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

Access namespace post-create interceptor chain

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

Access namespace pre-update interceptor chain

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

Access namespace post-update interceptor chain

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

Access namespace pre-delete interceptor chain

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

Access table definition post-create interceptor chain

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

Access table definition pre-update interceptor chain

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

Access table definition post-update interceptor chain

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

Access table definition pre-delete interceptor chain

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

Access view post-create interceptor chain

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

Access view pre-update interceptor chain

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

Access view post-update interceptor chain

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

Access view pre-delete interceptor chain

fn ring_buffer_def_post_create_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferDefPostCreateInterceptor<StandardCommandTransaction>>

Access ring buffer definition post-create interceptor chain

fn ring_buffer_def_pre_update_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferDefPreUpdateInterceptor<StandardCommandTransaction>>

Access ring buffer definition pre-update interceptor chain

fn ring_buffer_def_post_update_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferDefPostUpdateInterceptor<StandardCommandTransaction>>

Access ring buffer definition post-update interceptor chain

fn ring_buffer_def_pre_delete_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn RingBufferDefPreDeleteInterceptor<StandardCommandTransaction>>

Access ring buffer definition pre-delete interceptor chain

fn view_pre_insert_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn ViewPreInsertInterceptor<StandardCommandTransaction>>

Access view pre-insert interceptor chain

fn view_post_insert_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn ViewPostInsertInterceptor<StandardCommandTransaction>>

Access view post-insert interceptor chain

fn view_pre_update_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn ViewPreUpdateInterceptor<StandardCommandTransaction>>

Access view pre-update interceptor chain

fn view_post_update_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn ViewPostUpdateInterceptor<StandardCommandTransaction>>

Access view post-update interceptor chain

fn view_pre_delete_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn ViewPreDeleteInterceptor<StandardCommandTransaction>>

Access view pre-delete interceptor chain

fn view_post_delete_interceptors( &mut self, ) -> &mut Chain<StandardCommandTransaction, dyn ViewPostDeleteInterceptor<StandardCommandTransaction>>

Access view post-delete interceptor chain

impl Execute<StandardCommandTransaction, StandardQueryTransaction> for Executor

impl TransactionalChanges for StandardCommandTransaction