Enum StandardTransaction 

pub enum StandardTransaction<'a> {
    Command(&'a mut StandardCommandTransaction),
    Query(&'a mut StandardQueryTransaction),
}

An enum that can hold either a command or query transaction for flexible execution

Variants

Command(&'a mut StandardCommandTransaction)

Query(&'a mut StandardQueryTransaction)

Implementations

impl<'a> StandardTransaction<'a>

pub fn version(&self) -> CommitVersion

Get the transaction version

pub fn id(&self) -> TransactionId

Get the transaction ID

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

Get a value by key (async method)

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

Check if a key exists (async method)

pub async fn range_batch( &mut self, range: EncodedKeyRange, batch_size: u64, ) -> Result<MultiVersionBatch>

Get a range batch (async method)

pub async fn range_rev_batch( &mut self, range: EncodedKeyRange, batch_size: u64, ) -> Result<MultiVersionBatch>

Get a reverse range batch (async method)

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

Get a prefix batch (async method)

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

Get a reverse prefix batch (async method)

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

Read as of version exclusive (async method)

impl<'a> StandardTransaction<'a>

pub fn command(self) -> &'a mut StandardCommandTransaction

Extract the underlying StandardCommandTransaction, panics if this is a Query transaction

pub fn query(self) -> &'a mut StandardQueryTransaction

Extract the underlying StandardQueryTransaction, panics if this is a Command transaction

pub fn command_mut(&mut self) -> &mut StandardCommandTransaction

Get a mutable reference to the underlying StandardCommandTransaction, panics if this is a Query transaction

pub fn query_mut(&mut self) -> &mut StandardQueryTransaction

Get a mutable reference to the underlying StandardQueryTransaction, panics if this is a Command transaction

pub fn catalog(&self) -> &MaterializedCatalog

Trait Implementations

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<'a> From<&'a mut StandardQueryTransaction> for StandardTransaction<'a>

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

Converts to this type from the input type.

impl<'a> MultiVersionQueryTransaction for StandardTransaction<'a>

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<'a> QueryTransaction for StandardTransaction<'a>

type SingleVersionQuery<'b> = <StandardQueryTransaction as QueryTransaction>::SingleVersionQuery<'b> where Self: 'b

type CdcQuery<'b> = <StandardQueryTransaction as QueryTransaction>::CdcQuery<'b> where Self: 'b

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

where I: IntoIterator<Item = &'c EncodedKey> + Send + 'async_trait, Self: 'async_trait, 'c: '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,