Struct mmtkvdb::TxnRo

pub struct TxnRo<'a> { /* private fields */ }

Read-only transaction

A read-only transaction can be started with EnvRo::txn_ro.

The methods for read-only access to the database are accessible through the Txn trait (which is implemented by TxnRo and TxnRw).

Read-only transactions do not need to be committed or aborted; their handles can be simply dropped when not needed anymore.

Read-only transactions are Send and Sync but can’t modify any data.

Trait Implementations

impl<'a> Debug for TxnRo<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Txn for TxnRo<'a>

fn get<'kr, K, V, C, KRef>(
    &self,
    db: &Db<K, V, C>,
    key: KRef
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable,
    C: Constraint,
    KRef: StorableRef<'kr, K>, 

Get reference to value in database

fn new_cursor<K, V, C>(
    &self,
    db: &Db<K, V, C>
) -> Result<Cursor<K, V, C>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Create a new cursor

fn cursor_get_current_value_count<K, V>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>
) -> Result<usize, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Get number of values for current cursor position

fn cursor_set_first<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<bool, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Set cursor to first entry in database

fn cursor_set_first_get_pair<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<(K::AlignedRef<'_>, V::AlignedRef<'_>)>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Set cursor to first entry in database and get pair

fn cursor_set_last<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<bool, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Set cursor to last entry in database

fn cursor_set_last_get_pair<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<(K::AlignedRef<'_>, V::AlignedRef<'_>)>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Set cursor to last entry in database and get pair

fn cursor_get_current_key<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<K::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Get key at current cursor position

fn cursor_get_current_value<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Get value at current cursor position

fn cursor_get_current_pair<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<(K::AlignedRef<'_>, V::AlignedRef<'_>)>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Get key-value pair at current cursor position

fn cursor_set_key<'kr, K, V, C, KRef>(
    &self,
    cursor: &Cursor<K, V, C>,
    key: KRef
) -> Result<bool, Error> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable,
    C: Constraint,
    KRef: StorableRef<'kr, K>, 

Set cursor to key

fn cursor_set_key_get_value<'kr, K, V, C, KRef>(
    &self,
    cursor: &Cursor<K, V, C>,
    key: KRef
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable,
    C: Constraint,
    KRef: StorableRef<'kr, K>, 

Set cursor to key and get value

fn cursor_search_key_get_pair<'kr, K, V, C, KRef>(
    &self,
    cursor: &Cursor<K, V, C>,
    key: KRef
) -> Result<Option<(K::AlignedRef<'_>, V::AlignedRef<'_>)>, Error> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable,
    C: Constraint,
    KRef: StorableRef<'kr, K>, 

Set cursor to key or next greater key if not existent and get pair

fn cursor_set_next_get_pair<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<(K::AlignedRef<'_>, V::AlignedRef<'_>)>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Move cursor to next entry in database and get pair

fn cursor_set_prev_get_pair<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<(K::AlignedRef<'_>, V::AlignedRef<'_>)>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Move cursor to previous entry in database and get pair

fn cursor_set_next_key_get_pair<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<(K::AlignedRef<'_>, V::AlignedRef<'_>)>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Move cursor to first value of next key and get pair

fn cursor_set_prev_key_get_pair<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>
) -> Result<Option<(K::AlignedRef<'_>, V::AlignedRef<'_>)>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Move cursor to last value of previous key and get pair

fn cursor_set_first_value<K, V>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>
) -> Result<bool, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Move cursor to first value of current key

fn cursor_set_first_value_get_value<K, V>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Move cursor to first value of current key and get value

fn cursor_set_last_value<K, V>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>
) -> Result<bool, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Move cursor to last value of current key

fn cursor_set_last_value_get_value<K, V>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Move cursor to last value of current key and get value

fn cursor_set_pair<'kr, 'vr, K, V, KRef, VRef>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>,
    key: KRef,
    value: VRef
) -> Result<bool, Error> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable + 'vr,
    KRef: StorableRef<'kr, K>,
    VRef: StorableRef<'vr, V>, 

Set cursor to key-value pair

fn cursor_set_key_search_value_get_value<'kr, 'vr, K, V, KRef, VRef>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>,
    key: KRef,
    value: VRef
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable + 'vr,
    KRef: StorableRef<'kr, K>,
    VRef: StorableRef<'vr, V>, 

Set cursor to key and value or next greater value if not existent and get value

fn cursor_set_next_value_get_value<K, V>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Move cursor to next value of current key and get value

fn cursor_set_prev_value_get_value<K, V>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Move cursor to next value of current key and get value

fn get_owned<'a, 'kr, K, V, C, KRef>(
    &'a self,
    db: &Db<K, V, C>,
    key: KRef
) -> Result<Option<<<V as Storable>::AlignedRef<'a> as IntoOwned>::Owned>, Error> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable,
    C: Constraint,
    KRef: StorableRef<'kr, K>, 

Get owned value from database

impl<'a> Send for TxnRo<'a>

impl<'a> Sync for TxnRo<'a>