Struct sanakirja::MutTxn

pub struct MutTxn<E: Borrow<Env<Exclusive>>, T> { /* fields omitted */ }

A mutable transaction.

Implementations

impl<E: Borrow<Env<Exclusive>> + Clone, T> MutTxn<E, T>

pub fn mut_txn_begin<'txn>(
    &'txn mut self
) -> Result<MutTxn<E, &'txn mut MutTxn<E, T>>, Error>

Start a mutable sub-transaction.

impl<E: Borrow<Env<Exclusive>>, T> MutTxn<E, T>

pub fn put<R: Rng, K: Representable, V: Representable>(
    &mut self,
    rng: &mut R,
    db: &mut Db<K, V>,
    key: K,
    value: V
) -> Result<bool, Error>

Insert a binding to a database, returning false if and only if the exact same binding (key and value) was already in the database.

impl<E: Borrow<Env<Exclusive>>, T> MutTxn<E, T>

pub fn del<R: Rng, K: Representable, V: Representable>(
    &mut self,
    rng: &mut R,
    db: &mut Db<K, V>,
    key: K,
    value: Option<V>
) -> Result<bool, Error>

If value is None, delete one of the bindings associated to key from the database (without any specific preference). Else, delete the specified binding if present.

impl<E: Borrow<Env<Exclusive>>, T> MutTxn<E, T>

pub fn create_db<K: Representable, V: Representable>(
    &mut self
) -> Result<Db<K, V>, Error>

Creates a new database, complexity O(1).

pub fn set_root<K: Representable, V: Representable>(
    &mut self,
    root: usize,
    value: Db<K, V>
)

Sets the specified root to the given value. At most 508 different roots are allowed.

pub fn fork<R: Rng, K: Representable, V: Representable>(
    &mut self,
    rng: &mut R,
    db: &Db<K, V>
) -> Result<Db<K, V>, Error>

Fork a database, in O(log n), where n is the number of pages with reference count at least 2 (this complexity is also O(log |db|)).

pub fn drop<R: Rng, K: Representable, V: Representable>(
    &mut self,
    rng: &mut R,
    db: &Db<K, V>
) -> Result<(), Error>

Drop a database, in O(n).

Trait Implementations

impl<'a, E: Borrow<Env<Exclusive>>, T> Commit for MutTxn<E, &'a mut MutTxn<E, T>>

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

Commit the transaction.

impl<E: Borrow<Env<Exclusive>>> Commit for MutTxn<E, ()>

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

Commit a transaction. This is guaranteed to be atomic: either the commit succeeds, and all the changes made during the transaction are written to disk. Or the commit doesn't succeed, and we're back to the state just before starting the transaction.

impl<E: Borrow<Env<Exclusive>>, T> Drop for MutTxn<E, T>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<E: Borrow<Env<Exclusive>>, A> LoadPage for MutTxn<E, A>

pub fn load_page(&self, off: u64) -> Result<Page, CRCError>

Loading a page.

pub fn root_(&self, num: usize) -> u64

Offset (in bytes, from the beginning of the file) to root number num.

impl<E: Borrow<Env<Exclusive>>, T> Transaction for MutTxn<E, T>

pub fn iter<'a, K: Representable, V: Representable>(
    &'a self,
    db: &'a Db<K, V>,
    key: Option<(K, Option<V>)>
) -> Result<DbIterator<'a, Self, K, V>, CRCError>

Iterate over a database, starting at the first value larger than or equal to (key, value) (and at the smallest key, or smallest value if one or both of them is None).

pub fn rev_iter<'a, K: Representable, V: Representable>(
    &'a self,
    db: &'a Db<K, V>,
    key: Option<(K, Option<V>)>
) -> Result<RevDbIterator<'a, Self, K, V>, CRCError>

Iterate over a database in the reverse order, starting from the last binding strictly before k (or from the last binding in the table if k.is_none()).

pub fn set_cursors<K: Representable, V: Representable>(
    &self,
    root: &Db<K, V>,
    key: Option<(K, Option<V>)>
) -> Result<(Cursor, bool), CRCError>

Create a cursor positionned just on the largest (key, value) that is strictly smaller than key (at the beginning if key.is_none()).

pub fn set_cursors_last<K: Representable, V: Representable>(
    &self,
    root: &Db<K, V>
) -> Result<Cursor, CRCError>

Create a cursor positionned just on the largest (key, value) that is strictly smaller than key (at the beginning if key.is_none()).

pub fn root<K: Representable, V: Representable>(
    &self,
    root: usize
) -> Option<Db<K, V>>

Gets the specified root. At most 508 different roots are allowed.

pub fn get<'a, K: Representable, V: Representable>(
    &'a self,
    root: &Db<K, V>,
    key: K,
    value: Option<V>
) -> Result<Option<V>, CRCError>

Get the smallest value associated to key, or returns the given binding if value is Some(..) and is associated to key in the given database.