Struct rkv::Rkv

pub struct Rkv<E> { /* fields omitted */ }

Wrapper around an Environment (e.g. such as an LMDB or SafeMode environment).

Implementations

impl<'e, E> Rkv<E> where
    E: BackendEnvironment<'e>, 

Static methods.

pub fn environment_builder<B>() -> B where
    B: BackendEnvironmentBuilder<'e, Environment = E>, 

pub fn new<B>(path: &Path) -> Result<Rkv<E>, StoreError> where
    B: BackendEnvironmentBuilder<'e, Environment = E>, 

Return a new Rkv environment that supports up to DEFAULT_MAX_DBS open databases.

pub fn with_capacity<B>(
    path: &Path,
    max_dbs: c_uint
) -> Result<Rkv<E>, StoreError> where
    B: BackendEnvironmentBuilder<'e, Environment = E>, 

Return a new Rkv environment that supports the specified number of open databases.

pub fn from_builder<B>(path: &Path, builder: B) -> Result<Rkv<E>, StoreError> where
    B: BackendEnvironmentBuilder<'e, Environment = E>, 

Return a new Rkv environment from the provided builder.

impl<'e, E> Rkv<E> where
    E: BackendEnvironment<'e>, 

Store creation methods.

pub fn get_dbs(&self) -> Result<Vec<Option<String>>, StoreError>

Return all created databases.

pub fn open_single<'s, T>(
    &self,
    name: T,
    opts: StoreOptions<E::Flags>
) -> Result<SingleStore<E::Database>, StoreError> where
    T: Into<Option<&'s str>>, 

Create or Open an existing database in (&u8 -> Single Value) mode. Note: that create=true cannot be called concurrently with other operations so if you are sure that the database exists, call this with create=false.

pub fn open_integer<'s, T, K>(
    &self,
    name: T,
    opts: StoreOptions<E::Flags>
) -> Result<IntegerStore<E::Database, K>, StoreError> where
    K: PrimitiveInt,
    T: Into<Option<&'s str>>, 

Create or Open an existing database in (Integer -> Single Value) mode. Note: that create=true cannot be called concurrently with other operations so if you are sure that the database exists, call this with create=false.

pub fn open_multi<'s, T>(
    &self,
    name: T,
    opts: StoreOptions<E::Flags>
) -> Result<MultiStore<E::Database>, StoreError> where
    T: Into<Option<&'s str>>, 

Create or Open an existing database in (&u8 -> Multiple Values) mode. Note: that create=true cannot be called concurrently with other operations so if you are sure that the database exists, call this with create=false.

pub fn open_multi_integer<'s, T, K>(
    &self,
    name: T,
    opts: StoreOptions<E::Flags>
) -> Result<MultiIntegerStore<E::Database, K>, StoreError> where
    K: PrimitiveInt,
    T: Into<Option<&'s str>>, 

Create or Open an existing database in (Integer -> Multiple Values) mode. Note: that create=true cannot be called concurrently with other operations so if you are sure that the database exists, call this with create=false.

impl<'e, E> Rkv<E> where
    E: BackendEnvironment<'e>, 

Read and write accessors.

pub fn read<T>(&'e self) -> Result<Reader<T>, StoreError> where
    E: BackendEnvironment<'e, RoTransaction = T>,
    T: BackendRoCursorTransaction<'e, Database = E::Database>, 

Create a read transaction. There can be multiple concurrent readers for an environment, up to the maximum specified by LMDB (default 126), and you can open readers while a write transaction is active.

pub fn write<T>(&'e self) -> Result<Writer<T>, StoreError> where
    E: BackendEnvironment<'e, RwTransaction = T>,
    T: BackendRwCursorTransaction<'e, Database = E::Database>, 

Create a write transaction. There can be only one write transaction active at any given time, so trying to create a second one will block until the first is committed or aborted.

impl<'e, E> Rkv<E> where
    E: BackendEnvironment<'e>, 

Other environment methods.

pub fn sync(&self, force: bool) -> Result<(), StoreError>

Flush the data buffers to disk. This call is only useful, when the environment was open with either NO_SYNC, NO_META_SYNC or MAP_ASYNC (see below). The call is not valid if the environment was opened with READ_ONLY.

Data is always written to disk when transaction.commit() is called, but the operating system may keep it buffered. LMDB always flushes the OS buffers upon commit as well, unless the environment was opened with NO_SYNC or in part NO_META_SYNC.

force: if true, force a synchronous flush. Otherwise if the environment has the NO_SYNC flag set the flushes will be omitted, and with MAP_ASYNC they will be asynchronous.

pub fn stat(&self) -> Result<E::Stat, StoreError>

Retrieve statistics about this environment.

It includes:

• Page size in bytes
• B-tree depth
• Number of internal (non-leaf) pages
• Number of leaf pages
• Number of overflow pages
• Number of data entries

pub fn info(&self) -> Result<E::Info, StoreError>

Retrieve information about this environment.

It includes:

• Map size in bytes
• The last used page number
• The last transaction ID
• Max number of readers allowed
• Number of readers in use

pub fn load_ratio(&self) -> Result<Option<f32>, StoreError>

Retrieve the load ratio (# of used pages / total pages) about this environment.

With the formular: (last_page_no - freelist_pages) / total_pages. A value of None means that the backend doesn't ever need to be resized.

pub fn set_map_size(&self, size: usize) -> Result<(), StoreError>

Sets the size of the memory map to use for the environment.

This can be used to resize the map when the environment is already open. You can also use Rkv::environment_builder() to set the map size during the Rkv initialization.

Note:

• No active transactions allowed when performing resizing in this process. It's up to the consumer to enforce that.

• The size should be a multiple of the OS page size. Any attempt to set a size smaller than the space already consumed by the environment will be silently changed to the current size of the used space.

• In the multi-process case, once a process resizes the map, other processes need to either re-open the environment, or call set_map_size with size 0 to update the environment. Otherwise, new transaction creation will fail with LmdbError::MapResized.

pub fn close_and_delete(self) -> Result<(), StoreError>

Closes this environment and deletes all its files from disk. Doesn't delete the folder used when opening the environment.

Trait Implementations

impl<E: Debug> Debug for Rkv<E>

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

Formats the value using the given formatter.