Struct mmtkvdb::TxnRw

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

Read-write transaction

A read-write transaction can be started with EnvRw::txn_rw.

The methods for read-only access to the database are accessible through the Txn trait (which is implemented by TxnRo and TxnRw). Methods for write access, however, are available directly on the TxnRw struct.

Read-write transactions are aborted when dropped. To make changes permanent, TxnRw::commit must be called.

Read-write transactions are neither Send nor Sync.

Implementations

impl<'a> TxnRw<'a>

pub fn commit(self) -> Result<()>

Commit transaction

pub fn abort(self)

Abort transaction (same as drop)

pub fn nested(&mut self) -> Result<TxnRw<'_>>

Start nested transaction

Panics if environment does not support nested transactions (which is the case when the EnvBuilder::writemap flag has been set).

pub fn put<'kr, 'vr, K, V, C, KRef, VRef>(
    &mut self,
    db: &Db<K, V, C>,
    key: KRef,
    value: VRef
) -> Result<()> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable + 'vr,
    C: Constraint,
    KRef: StorableRef<'kr, K>,
    VRef: StorableRef<'vr, V>, 

Put value into database

This will overwrite an existing value if the database does not use the DbOptions::keys_duplicate option.

pub fn put_unless_key_exists<'kr, 'vr, K, V, C, KRef, VRef>(
    &mut self,
    db: &Db<K, V, C>,
    key: KRef,
    value: VRef
) -> Result<bool> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable + 'vr,
    C: Constraint,
    KRef: StorableRef<'kr, K>,
    VRef: StorableRef<'vr, V>, 

Put value into database unless key exists

Returns Ok(false) if key exists.

pub fn put_unless_pair_exists<'kr, 'vr, K, V, KRef, VRef>(
    &mut self,
    db: &Db<K, V, KeysDuplicate>,
    key: KRef,
    value: VRef
) -> Result<bool> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable + 'vr,
    KRef: StorableRef<'kr, K>,
    VRef: StorableRef<'vr, V>, 

Put value into database unless key-value pair exists

Returns Ok(false) if key-value pair exists.

pub fn delete_key<'kr, K, V, C, KRef>(
    &mut self,
    db: &Db<K, V, C>,
    key: KRef
) -> Result<bool> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable,
    C: Constraint,
    KRef: StorableRef<'kr, K>, 

Delete all values from database that match a given key

pub fn delete_pair<'kr, 'vr, K, V, KRef, VRef>(
    &mut self,
    db: &Db<K, V, KeysDuplicate>,
    key: KRef,
    value: VRef
) -> Result<bool> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable + 'vr,
    KRef: StorableRef<'kr, K>,
    VRef: StorableRef<'vr, V>, 

Delete key-value pair from database

pub fn cursor_delete_current<K, V, C>(
    &mut self,
    cursor: &Cursor<K, V, C>
) -> Result<()> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Delete key-value pair at current cursor position

pub fn cursor_delete_current_key<K, V>(
    &mut self,
    cursor: &Cursor<K, V, KeysDuplicate>
) -> Result<()> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Delete all values with same key at current cursor position

Trait Implementations

impl<'a> Debug for TxnRw<'a>

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

Formats the value using the given formatter.

impl<'a> Txn for TxnRw<'a>

fn get<'kr, K, V, C, KRef>(
    &self,
    db: &Db<K, V, C>,
    key: KRef
) -> Result<Option<V::AlignedRef<'_>>> 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>> 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> 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> 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<'_>)>> 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> 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<'_>)>> 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<'_>>> 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<'_>>> 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<'_>)>> 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> 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<'_>>> 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<'_>)>> 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<'_>)>> 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<'_>)>> 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<'_>)>> 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<'_>)>> 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> 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<'_>>> 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> 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<'_>>> 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> 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<'_>>> 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<'_>>> 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<'_>>> 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 ToOwned>::Owned>> where
    K: ?Sized + Storable + 'kr,
    V: ?Sized + Storable + ToOwned,
    C: Constraint,
    KRef: StorableRef<'kr, K>, 

Get owned value from database