Struct mmtkvdb::TxnRw

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

Read-write transaction

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.

handles can be simply dropped when not needed anymore.

Read-write transactions are neither Send nor Sync.

Implementations

impl<'a> TxnRw<'a>

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

Commit transaction

pub fn abort(self)

Abort transaction (same as drop)

pub fn put<K, V, C>(
    &mut self,
    db: &Db<K, V, C>,
    key: &K,
    value: &V
) -> Result<(), Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Put value into database

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

Put value into database unless key exists

pub fn put_unless_pair_exists<K, V>(
    &mut self,
    db: &Db<K, V, KeysDuplicate>,
    key: &K,
    value: &V
) -> Result<bool, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Put value into database unless key-value pair exists

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

Delete all values from database that match a given key

pub fn delete_pair<K, V>(
    &mut self,
    db: &Db<K, V, KeysDuplicate>,
    key: &K,
    value: &V
) -> Result<bool, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Delete key-value pair from database

pub fn cursor_delete_current<K, V, C>(
    &mut self,
    cursor: &Cursor<K, V, C>
) -> Result<(), Error> 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<(), Error> 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<K, V, C>(
    &self,
    db: &Db<K, V, C>,
    key: &K
) -> Result<Option<V::AlignedRef<'_>>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

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<K, V, C>(
    &self,
    cursor: &Cursor<K, V, C>,
    key: &K
) -> Result<bool, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Set cursor to key

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

Set cursor to key and get value

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

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<K, V>(
    &self,
    cursor: &Cursor<K, V, KeysDuplicate>,
    key: &K,
    value: &V
) -> Result<bool, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable, 

Set cursor to key-value pair

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

Set cursor to key-value pair

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, K, V, C>(
    &'a self,
    db: &Db<K, V, C>,
    key: &K
) -> Result<Option<<<V as Storable>::AlignedRef<'a> as PointerIntoOwned>::Owned>, Error> where
    K: ?Sized + Storable,
    V: ?Sized + Storable,
    C: Constraint, 

Get owned value from database