Struct StandardQueryTransaction 

pub struct StandardQueryTransaction { /* private fields */ }

An active query transaction that holds a multi query transaction and provides query-only access to single storage.

Implementations

impl StandardQueryTransaction

pub fn new( multi: <TransactionMultiVersion as MultiVersionTransaction>::Query, single: TransactionSingle, cdc: TransactionCdc, catalog: MaterializedCatalog, ) -> Self

Creates a new active query transaction

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 fn with_multi_query<F, R>(&mut self, f: F) -> Result<R>

where F: FnOnce(&mut <TransactionMultiVersion as MultiVersionTransaction>::Query) -> Result<R>,

Execute a function with access to the multi query transaction. This operates within the same transaction context.

pub fn cdc(&self) -> &TransactionCdc

Get access to the CDC transaction interface

Trait Implementations

impl ExecuteQuery<StandardQueryTransaction> for Executor

fn execute_query<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, txn: &'life1 mut StandardQueryTransaction, qry: Query<'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 ExecuteQuery<StandardQueryTransaction> for StandardEngine

fn execute_query<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, txn: &'life1 mut StandardQueryTransaction, qry: Query<'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 StandardQueryTransaction> for StandardTransaction<'a>

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

Converts to this type from the input type.

impl MaterializedCatalogTransaction for StandardQueryTransaction

fn catalog(&self) -> &MaterializedCatalog

impl MultiVersionQueryTransaction for StandardQueryTransaction

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 StandardQueryTransaction

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

type CdcQuery<'a> = <TransactionCdc as CdcTransaction>::Query<'a> where Self: '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 StandardQueryTransaction

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 StandardQueryTransaction

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 StandardQueryTransaction

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 StandardQueryTransaction

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 StandardQueryTransaction

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 StandardQueryTransaction

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 Execute<StandardCommandTransaction, StandardQueryTransaction> for Executor

impl TransactionalChanges for StandardQueryTransaction