Struct sanakirja::MutTxn

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

A mutable transaction.

Implementations

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

pub fn env_borrow(&self) -> &Env

Borrow env

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

pub fn set_root(&mut self, num: usize, value: u64)

Setting the numth element of the initial page, treated as a [u64; 510], to value. This doesn’t actually write anything to that page, since that page is written during the commit.

In the current implementation, value is probably going to be the offset in the file of the root page of a B tree.

pub fn remove_root(&mut self, num: usize)

Setting the numth element of the initial page, treated as a [u64; 510].

impl<E: Borrow<Env>, A> MutTxn<E, A>

pub unsafe fn root_page_mut(&mut self) -> &mut [u8; 4064]

The root page of this transaction (use with caution, this page contains root databases).

pub unsafe fn root_page(&self) -> &[u8; 4064]

The root page of this transaction.

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

pub fn root(&self, n: usize) -> Option<u64>

Low-level method to get the root page number n, if that page isn’t a B tree (use the RootDb trait else).

Trait Implementations

impl<E: Borrow<Env>, T> AllocPage for MutTxn<E, T>

unsafe fn alloc_page(&mut self) -> Result<MutPage, Error>

Allocate a single page.

unsafe fn alloc_page_no_dirty(&mut self) -> Result<MutPage, Error>

Allocate a single page.

unsafe fn alloc_contiguous(&mut self, length: u64) -> Result<MutPage, Error>

Allocate many contiguous pages, return the first one

fn incr_rc(&mut self, off: u64) -> Result<usize, Error>

Increment the reference count for page off.

unsafe fn decr_rc(&mut self, off: u64) -> Result<usize, Error>

Decrement the page’s reference count, assuming the page was first allocated by another transaction. If the RC reaches 0, free the page. Must return the new RC (0 if freed).

unsafe fn decr_rc_owned(&mut self, off: u64) -> Result<usize, Error>

Same as Self::decr_rc, but for pages allocated by the current transaction. This is an important distinction, as pages allocated by the current transaction can be reused immediately after being freed.

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

The following is very easy, we’re just extending all values of the current transaction with values of the subtransaction.

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

Commit the transaction.

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

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

Commit the transaction.

impl<E: Borrow<Env>, T> Debug for MutTxn<E, T>

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

Formats the value using the given formatter.

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

When dropping a transaction, we need to unlock the read-write locks internal to this process, and possibly the file locks.

fn drop(&mut self)

Executes the destructor for this type.

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

type Error = Error

unsafe fn load_page(&self, off: u64) -> Result<CowPage, Self::Error>

Loading a page.

fn rc(&self, page: u64) -> Result<u64, Self::Error>

Reference-counting. Since reference-counts are designed to be storable into B trees by external allocators, pages referenced once aren’t stored, and hence are indistinguishable from pages that are never referenced. The default implementation returns 0.

unsafe fn load_page_contiguous( &self, _off: u64, _len: u64 ) -> Result<CowPage, Self::Error>

Loading multiple pages written contiguously in the underlying storage media.

impl<E: Borrow<Env>, T> RootDb for MutTxn<E, T>

fn root_db<K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>( &self, n: usize ) -> Option<Db_<K, V, P>>

Return the database stored in the root page of the current transaction at index n, if any.

impl<E: Borrow<Env>, T> RootPage for MutTxn<E, T>

unsafe fn root_page(&self) -> &[u8; 4064]

The root page of this transaction.