redb

https://docs.rs/redb/latest/
Admin
redb is a simple, portable, high-performance, ACID, embedded key-value store written in pure Rust,...
Tokens:389,281
Snippets:2,163
Trust Score:9.7
Update:2 days ago
Show doc for...
Tokens:
Raw
### Basic database usage example

Source: https://docs.rs/redb/latest/src/redb/db.rs.html

Basic usage example for the Database struct: creates a database, begins a write transaction, opens a table, inserts a value, and commits.

```rust
use redb::*;
# use tempfile::NamedTempFile;
const TABLE: TableDefinition<u64, u64> = TableDefinition::new("my_data");

# fn main() -> Result<(), Error> {
# #[cfg(not(target_os = "wasi"))]
# let tmpfile = NamedTempFile::new().unwrap();
# #[cfg(target_os = "wasi")]
# let tmpfile = NamedTempFile::new_in("/tmp").unwrap();
# let filename = tmpfile.path();
let db = Database::create(filename)?;
let write_txn = db.begin_write()?;
{
    let mut table = write_txn.open_table(TABLE)?;
    table.insert(&0, &0)?;
}
write_txn.commit()?;
# Ok(())
# }
```

--------------------------------

### Doctest: Remove a key using a cursor

Source: https://docs.rs/redb/latest/src/redb/table.rs.html

Example from the documentation for CursorMut::remove, showing how to create a database, open a table, use a cursor to find a key, and remove it. The example uses a temporary file and returns a Result.

```rust
///     let file = tempfile::NamedTempFile::new().unwrap();
///     # #[cfg(target_os = "wasi")]
///     # let file = tempfile::NamedTempFile::new_in("/tmp").unwrap();
///     let db = Database::create(file.path())?;
///     let txn = db.begin_write()?;
///     let mut table = txn.open_table(TABLE)?;
///     table.insert(1, 1)?;
///     let mut cursor = table.lower_bound(Bound::<u64>::Unbounded)?;
///     let key: u64 = cursor.next()?.unwrap().0.value();
///     table.remove(key)?;
///     Ok(())
/// }
```

--------------------------------

### Example: Using range to iterate over a range

Source: https://docs.rs/redb/latest/redb/trait.ReadableTable.html

Shows how to open a table, insert data, and use the range method to iterate over a range of keys. The example creates a database, writes three key-value pairs, then reads them back using a range from "a" to "c".

```rust
use redb::*;
const TABLE: TableDefinition<&str, u64> = TableDefinition::new("my_data");

let db = Database::create(filename)?;
let write_txn = db.begin_write()?;
{
    let mut table = write_txn.open_table(TABLE)?;
    table.insert("a", &0)?;
    table.insert("b", &1)?;
    table.insert("c", &2)?;
}
write_txn.commit()?;

let read_txn = db.begin_read()?;
let table = read_txn.open_table(TABLE)?;
let mut iter = table.range("a".."c")?;
let (key, value) = iter.next().unwrap()?;
assert_eq!("a", key.value());
assert_eq!(0, value.value());
```

--------------------------------

### Insert ascending keys with upper_bound_mut

Source: https://docs.rs/redb/latest/redb/struct.Table.html

Example from the upper_bound_mut documentation showing how to insert a stream of ascending keys through the gap at the end of the table. Uses Bound::<u64>::Unbounded to get a cursor at the end, then inserts keys 0..1000 with values key*2, closes the cursor, and asserts the table length is 1000.

```rust
use std::ops::Bound;
use redb::{Database, Error, ReadableTableMetadata, TableDefinition};
const TABLE: TableDefinition<u64, u64> = TableDefinition::new("my_data");

let db = Database::create(filename)?;
let write_txn = db.begin_write()?;
{
    let mut table = write_txn.open_table(TABLE)?;
    let mut cursor = table.upper_bound_mut(Bound::<u64>::Unbounded)?;
    for key in 0..1000 {
        cursor.insert_before(key, &(key * 2))?;
    }
    cursor.close()?;
    assert_eq!(table.len()?, 1000);
}
write_txn.commit()?;
```

--------------------------------

### Basic usage of ReadOnlyDatabase

Source: https://docs.rs/redb/latest/redb/struct.ReadOnlyDatabase.html

Example showing how to create a database, write data, then open it in read-only mode and read the data.

```rust
use redb::*;
const TABLE: TableDefinition<u64, u64> = TableDefinition::new("my_data");

let db = Database::create(filename)?;
let txn = db.begin_write()?;
{
    let mut table = txn.open_table(TABLE)?;
    table.insert(&0, &0)?;
}
txn.commit()?;
drop(db);

let db = ReadOnlyDatabase::open(filename)?;
let txn = db.begin_read()?;
{
    let mut table = txn.open_table(TABLE)?;
    println!("{}", table.get(&0)?.unwrap().value());
}
```

--------------------------------

### step_by

Source: https://docs.rs/redb/latest/redb/struct.OwnedMultimapRange.html

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

```APIDOC
## step_by

### Description
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

### Method
step_by

### Signature
fn step_by(self, step: usize) -> StepBy<Self>

### Parameters
- **step** (usize) - Required - The number of steps to advance at each iteration.

### Return Value
StepBy<Self> - An iterator that steps by the given amount.

```

--------------------------------

### step_by

Source: https://docs.rs/redb/latest/redb/struct.OwnedMultimapRange.html

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

```APIDOC
## step_by

### Description
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

### Method
step_by

### Signature
fn step_by(self, step: usize) -> StepBy<Self> where Self: Sized

### Parameters
- step (usize) - Required - The amount to step by.

### Returns
- StepBy<Self> - An iterator that steps by the given amount.

### Notes
This is a method from the Iterator trait.
```

--------------------------------

### Key implementation for &str (beginning)

Source: https://docs.rs/redb/latest/src/redb/types.rs.html

Starts the Key trait implementation for &str, providing the compare method that decodes both byte slices as UTF-8 strings and compares them with str::cmp.

```rust
impl Key for &str {
    fn compare(data1: &[u8], data2: &[u8]) -> Ordering {
        let str1 = Self::from_bytes(data1);
        let str2 = Self::from_bytes(data2);
        str1.cmp(str2)
    }

    fn separator<'a>(left: &'a [u8], right: &'a [u8]) -> Cow<'a, [u8]> {
```

--------------------------------

### Begin write transaction with default allocation policy

Source: https://docs.rs/redb/latest/src/redb/db.rs.html

Starts a write transaction, blocking if another write is in progress. The returned transaction is not lifetime-bound to the Database and keeps it open.

```rust
/// Begins a write transaction
///
/// Returns a [`WriteTransaction`] which may be used to read/write to the database. Only a single
/// write may be in progress at a time. If a write is in progress, this function will block
/// until it completes.
///
/// The returned transaction is not lifetime-bound to this [`Database`] and keeps the
/// database open: if the [`Database`] is dropped while the transaction is live, the
/// transaction remains usable and the database closes when the transaction completes.
pub fn begin_write(&self) -> Result<WriteTransaction, TransactionError> {
    self.begin_write_with(None, None)
}

fn begin_write_with(
    &self,
    writer_lock: Option<&Arc<WriterLock>>,
    header_lock: Option<&HeaderGuard<'_>>,
) -> Result<WriteTransaction, TransactionError> {
    begin_write_with_allocation_policy(
        &self.transaction_tracker,
        &self.mem,
        writer_lock,
        header_lock,
        AllocationPolicy::Default,
    )
}
```

--------------------------------

### Iterate and remove key from table range

Source: https://docs.rs/redb/latest/src/redb/table.rs.html

Doctest example showing how to iterate over a table range, get the first key, and remove it. Uses the experimental-api-5 feature.

```rust
///     let mut range = table.iter()?;
///     let key: u64 = range.next().unwrap()?.0.value();
///     table.remove(key)?;
///     Ok(())
/// }
/// ```
```

--------------------------------

### Basic redb usage: create database, write and read a value

Source: https://docs.rs/redb/latest/redb/

Shows how to create a redb database, open a table, insert a key-value pair, commit the write transaction, and read the value back in a read transaction. Uses TableDefinition to define the table schema and requires the tempfile crate for the example.

```rust
use redb::{Database, Error, ReadableDatabase, ReadableTable, TableDefinition};

const TABLE: TableDefinition<&str, u64> = TableDefinition::new("my_data");

fn main() -> Result<(), Error> {
    let file = tempfile::NamedTempFile::new().unwrap();
    let db = Database::create(file.path())?;
    let write_txn = db.begin_write()?;
    {
        let mut table = write_txn.open_table(TABLE)?;
        table.insert("my_key", &123)?;
    }
    write_txn.commit()?;

    let read_txn = db.begin_read()?;
    let table = read_txn.open_table(TABLE)?;
    assert_eq!(table.get_owned("my_key")?.unwrap().value(), 123);

    Ok(())
}
```

--------------------------------

### Basic usage of redb Database

Source: https://docs.rs/redb/latest/redb/struct.Database.html

Shows how to create a database, open a write transaction, insert data into a table, and commit the transaction. Uses the TableDefinition 'my_data' with u64 keys and values.

```rust
use redb::*;
const TABLE: TableDefinition<u64, u64> = TableDefinition::new("my_data");

let db = Database::create(filename)?;
let write_txn = db.begin_write()?;
{
    let mut table = write_txn.open_table(TABLE)?;
    table.insert(&0, &0)?;
}
write_txn.commit()?;
```

--------------------------------

### Builder::create

Source: https://docs.rs/redb/latest/redb/struct.Builder.html

Opens the specified file as a redb database. If the file does not exist or is empty, a new database is initialized; if it is a valid redb database, it is opened; otherwise an error is returned.

```APIDOC
## Builder::create

### Description
Opens the specified file as a redb database. If the file does not exist, or is an empty file, a new database will be initialized in it. If the file is a valid redb database, it will be opened. Otherwise this function will return an error.

### Method
`pub fn create(&self, path: impl AsRef<Path>) -> Result<Database, DatabaseError>`

### Parameters
- `path` (impl AsRef<Path>) - Required - The file path to open or create.

### Returns
- `Result<Database, DatabaseError>` - The opened database or an error.

```

--------------------------------

### Table::entry

Source: https://docs.rs/redb/latest/redb/struct.Table.html

Gets the given key's corresponding entry in the table for in-place manipulation. Avoids the double lookup that a get followed by insert would require when updating a value.

```APIDOC
## Table::entry

### Description
Gets the given key's corresponding entry in the table for in-place manipulation. This is analogous to `std::collections::BTreeMap::entry` and avoids the double lookup that a `get` followed by `insert` would require when updating a value.

### Method
`pub fn entry<'a>(&'a mut self, key: K::SelfType<'a>) -> Result<Entry<'a, K, V>>`

### Parameters
- `key` (K::SelfType<'a>) - Required - The key to get the entry for.

### Returns
- `Result<Entry<'a, K, V>>` - The entry for the given key.

### Example
```rust
use redb::{Database, TableDefinition};

let db = Database::create("my_db")?;
let write_txn = db.begin_write()?;
{
    let mut table = write_txn.open_table(TableDefinition::<u64, u64>::new("my_data"))?;
    let entry = table.entry(42)?;
    // ...
}
write_txn.commit()?;
```
```

--------------------------------

### Compile-fail example: MultimapRange keeps table borrowed

Source: https://docs.rs/redb/latest/src/redb/multimap_table.rs.html

A compile-fail doctest showing that a MultimapRange holds the table borrowed, preventing mutation while the range is alive. The example attempts to insert after creating a range and fails with E0502.

```rust
use redb::{Database, MultimapTableDefinition, ReadableMultimapTable};

const TABLE: MultimapTableDefinition<u64, u64> = MultimapTableDefinition::new("my_data");

fn main() -> Result<(), redb::Error> {
    # #[cfg(not(target_os = "wasi"))]
    let file = tempfile::NamedTempFile::new().unwrap();
    # #[cfg(target_os = "wasi")]
    # let file = tempfile::NamedTempFile::new_in("/tmp").unwrap();
    let db = Database::create(file.path())?;
    let txn = db.begin_write()?;
    let mut table = txn.open_multimap_table(TABLE)?;
    table.insert(1, 1)?;
    let mut range = table.iter()?;
    let key: u64 = range.next().unwrap()?.0.value();
    table.insert(key, 2)?;
    Ok(())
}
```

--------------------------------

### Database::create

Source: https://docs.rs/redb/latest/src/redb/db.rs.html

Opens the specified file as a redb database. If the file does not exist or is empty, a new database is initialized. If the file is a valid redb database, it is opened; otherwise an error is returned.

```APIDOC
## Database::create

### Description
Opens the specified file as a redb database. If the file does not exist or is empty, a new database is initialized. If the file is a valid redb database, it is opened; otherwise an error is returned.

### Method
create

### Signature
pub fn create(path: impl AsRef<Path>) -> Result<Database, DatabaseError>

### Parameters
- **path** (impl AsRef<Path>) - Required - Path to the database file.

### Returns
- **Result<Database, DatabaseError>** - The opened or created database, or an error if the file is not a valid redb database.

### Example
```rust
let db = Database::create(filename)?;
```
```

--------------------------------

### Builder::open

Source: https://docs.rs/redb/latest/redb/struct.Builder.html

Opens an existing redb database.

```APIDOC
## Builder::open

### Description
Opens an existing redb database.

### Method
`pub fn open(&self, path: impl AsRef<Path>) -> Result<Database, DatabaseError>`

### Parameters
- `path` (impl AsRef<Path>) - Required - The file path to open.

### Returns
- `Result<Database, DatabaseError>` - The opened database or an error.

```

--------------------------------

### len

Source: https://docs.rs/redb/latest/redb/backends/struct.FileBackend.html

Gets the current length of the storage.

```APIDOC
## len

### Description
Gets the current length of the storage.

### Method
len

### Signature
fn len(&self) -> Result<u64, Error>

### Parameters
None.

### Returns
- **Result<u64, Error>** - Returns the current length of the storage, or an error.

```

--------------------------------

### WriteTransaction::get_persistent_savepoint

Source: https://docs.rs/redb/latest/redb/struct.WriteTransaction.html

Get a persistent savepoint given its id.

```APIDOC
## WriteTransaction::get_persistent_savepoint

### Description
Get a persistent savepoint given its id.

### Method
`pub fn get_persistent_savepoint(&self, id: u64) -> Result<Savepoint, SavepointError>`

### Parameters
- `id` (u64) - Required - The ID of the savepoint to retrieve.

### Returns
- `Result<Savepoint, SavepointError>` - On success, returns the `Savepoint` associated with the given ID. On error, returns a `SavepointError`.

```

--------------------------------

### Builder::create_with_backend

Source: https://docs.rs/redb/latest/redb/struct.Builder.html

Opens an existing or creates a new database with the given storage backend.

```APIDOC
## Builder::create_with_backend

### Description
Opens an existing or creates a new database with the given storage backend.

### Method
`create_with_backend`

### Signature
`pub fn create_with_backend(&self, backend: impl StorageBackend) -> Result<Database, DatabaseError>`

### Parameters
- `backend` (impl StorageBackend) - Required - The storage backend to use for the database.

### Returns
- `Result<Database, DatabaseError>` - A `Database` on success, or a `DatabaseError` on failure.
```

--------------------------------

### impl<T> Any for T

Source: https://docs.rs/redb/latest/redb/struct.CursorMut.html

Provides the type_id method to get the TypeId of the value.

```APIDOC
## impl<T> Any for T

### Description
Provides the `type_id` method to get the `TypeId` of the value.

### Method
`fn type_id(&self) -> TypeId`

### Parameters
- `&self` - The value to get the type ID of.

### Returns
- `TypeId` - The `TypeId` of `self`.

```

--------------------------------

### Create new database in empty file

Source: https://docs.rs/redb/latest/src/redb/db.rs.html

Uses Database::builder().create_file() to create a new database in an empty file.

```rust
let tmpfile = crate::create_tempfile();

let _db = Database::builder()
    .create_file(tmpfile.into_file())
    .unwrap();
```

--------------------------------

### Get Transaction Guard

Source: https://docs.rs/redb/latest/src/redb/transactions.rs.html

Returns a clone of the transaction guard as an Arc<TransactionGuard>.

```rust
pub(crate) fn transaction_guard(&self) -> Arc<TransactionGuard> {
    self.transaction_guard.clone()
}
```

--------------------------------

### Compact database after deleting entries

Source: https://docs.rs/redb/latest/src/redb/db.rs.html

Creates a database with a 256 KiB region size, inserts 4096 entries of 1024 bytes each, removes all but one, then compacts and asserts the file size is less than two region sizes.

```rust
let table_definition: TableDefinition<u64, &[u8]> = TableDefinition::new("x");
let region_size = 256 * 1024;
let mut db = Database::builder()
    .set_region_size(region_size)
    .create(tmpfile.path())
    .unwrap();

let txn = db.begin_write().unwrap();
{
    let mut table = txn.open_table(table_definition).unwrap();
    for i in 0..4096 {
        table.insert(i, [0u8; 1024].as_slice()).unwrap();
    }
}
txn.commit().unwrap();
let txn = db.begin_write().unwrap();
{
    let mut table = txn.open_table(table_definition).unwrap();
    for i in 0..4095 {
        table.remove(i).unwrap();
    }
}
txn.commit().unwrap();

assert!(db.compact().unwrap());
let file_size = tmpfile.as_file().metadata().unwrap().len();
assert!(file_size < 2 * region_size, "{file_size}");
```

--------------------------------

### get

Source: https://docs.rs/redb/latest/redb/struct.MultimapTable.html

Returns an iterator over all values for the given key. Values are in ascending order.

```APIDOC
## get

### Description
Returns an iterator over all values for the given key. Values are in ascending order.

### Method
`fn get<'a>(&self, key: impl Borrow<K::SelfType<'a>>) -> Result<MultimapValue<'_, V>>`

### Parameters
- **key** (impl Borrow<K::SelfType<'a>>) - Required - The key to look up values for.

### Returns
- **Result<MultimapValue<'_, V>>** - An iterator over all values associated with the key, in ascending order.
```

--------------------------------

### FileBackend set_len, sync_data, and write methods

Source: https://docs.rs/redb/latest/src/redb/tree_store/page_store/file_backend/optimized.rs.html

Implements `set_len`, `sync_data`, and platform-specific `write` methods for Unix, WASI, and Windows. The Windows version loops with `seek_write` and treats a zero write as `WriteZero` to avoid infinite loops.

```rust
    fn set_len(&self, len: u64) -> Result<(), io::Error> {
        self.file.set_len(len)
    }

    fn sync_data(&self) -> Result<(), io::Error> {
        self.file.sync_data()
    }

    #[cfg(unix)]
    fn write(&self, offset: u64, data: &[u8]) -> Result<(), io::Error> {
        self.file.write_all_at(data, offset)
    }

    #[cfg(target_os = "wasi")]
    fn write(&self, offset: u64, data: &[u8]) -> Result<(), io::Error> {
        write_all_at(&self.file, data, offset)
    }

    #[cfg(windows)]
    fn write(&self, mut offset: u64, data: &[u8]) -> Result<(), io::Error> {
        let mut data_offset = 0;
        while data_offset < data.len() {
            let written = self.file.seek_write(&data[data_offset..], offset)?;
            // seek_write can report zero bytes written; treat that as an error so the write
            // fails instead of looping forever, like the read loop above.
            if written == 0 {
                return Err(io::Error::new(
                    io::ErrorKind::WriteZero,
                    "failed to write whole buffer",
                ));
            }
            offset += written as u64;
            data_offset += written;
        }
        Ok(())
    }
```

--------------------------------

### Database open: restore savepoints and handle multi-writer mode

Source: https://docs.rs/redb/latest/src/redb/db.rs.html

Initializes the transaction tracker, restores persistent savepoints, and in multi-writer mode ensures the allocator state table is trimmed after a repair. Constructs the Database only after initialization succeeds.

```rust
mem.mark_consistent()?;
mem.begin_writable()?;
let next_transaction_id = mem.get_last_committed_transaction_id()?.next();

let transaction_tracker = Arc::new(TransactionTracker::new(next_transaction_id));

// Restore the tracker state for any persistent savepoints
Self::sync_persistent_savepoints(&transaction_tracker, &mem, writer_lock.as_ref())?;
// In multi-writer mode a repair ends with a commit recording the allocator state, as
// compaction and the integrity check do, so that the next open, in any process, loads it
if repaired && concurrency_mode == ConcurrencyMode::MultiWriter {
    ensure_allocator_state_table_and_trim(
        &transaction_tracker,
        &mem,
        writer_lock.as_ref(),
        None,
    )?;
}
// Construct only after initialization succeeds: Database::drop takes the writer lock,
// which the open still holds, and assumes the savepoint tracker is complete.
Ok(Database {
    mem,
    transaction_tracker,
})
```

--------------------------------

### get

Source: https://docs.rs/redb/latest/redb/struct.Table.html

Returns the value corresponding to the given key. The key is borrowed and the value is returned as an AccessGuard.

```APIDOC
## get

### Description
Returns the value corresponding to the given key.

### Method
fn get<'a>(&self, key: impl Borrow<K::SelfType<'a>>) -> Result<Option<AccessGuard<'_, V>>>
```

--------------------------------

### take

Source: https://docs.rs/redb/latest/redb/struct.ExtractIf.html

Creates an iterator that yields the first n elements.

```APIDOC
## take

### Description
Creates an iterator that yields the first n elements.

### Method
take

### Signature
fn take(self, n: usize) -> Take<Self>
where Self: Sized

### Parameters
- **n** (usize) - Required - The number of elements to yield.

### Returns
- **Take<Self>** - An iterator that yields the first n elements.

```

--------------------------------

### Test utilities for B-tree pages

Source: https://docs.rs/redb/latest/src/redb/tree_store/btree_base.rs.html

Helper functions for tests: make_allocator, make_allocator_with_page_size, build_leaf, and ascending_keys. These set up an in-memory transactional memory and build leaf pages with fixed-width keys.

```rust
    const MAX_PAIRS: usize = u16::MAX as usize;

    fn make_allocator() -> PageAllocator {
        make_allocator_with_page_size(PAGE_SIZE)
    }

    fn make_allocator_with_page_size(page_size: usize) -> PageAllocator {
        let (mem, _writer_lock) = TransactionalMemory::new(
            Box::new(InMemoryBackend::new()),
            true,
            page_size,
            None,
            0,
            false,
            crate::db::ConcurrencyMode::ExclusiveWriter,
        )
        .unwrap();
        mem.reset_allocator_state().unwrap();
        PageAllocator::new(Arc::new(mem), AllocationPolicy::Default)
    }

    fn build_leaf(
        page_allocator: &PageAllocator,
        allocated_pages: &PageTracker,
        keys: &[[u8; 8]],
    ) -> PageMut<'static> {
        let mut builder = LeafBuilder::new(
            page_allocator,
            allocated_pages,
            keys.len(),
            u64::fixed_width(),
            None,
        );
        for key in keys {
            builder.push(key, &[]);
        }
        builder.build().unwrap()
    }

    fn ascending_keys(n: usize) -> Vec<[u8; 8]> {
        (0..n as u64).map(|i| i.to_le_bytes()).collect()
    }
```

--------------------------------

### InMemoryBackend::len

Source: https://docs.rs/redb/latest/redb/backends/struct.InMemoryBackend.html

Gets the current length of the storage. This method is part of the `StorageBackend` trait implementation.

```APIDOC
## InMemoryBackend::len

### Description
Gets the current length of the storage.

### Method
`fn len(&self) -> Result<u64, Error>`

### Parameters
- `&self` - The backend instance.

### Returns
- `Result<u64, Error>` - The current length of the storage as a `u64`, or an `Error` if the operation fails.

### Example
```rust
let len = backend.len()?;
```
```

--------------------------------

### Small Pages Test with Cache Size and Page Size

Source: https://docs.rs/redb/latest/src/redb/db.rs.html

Creates a database with a 1 MB cache and 1024-byte page size, then begins a write transaction with a table definition.

```rust
let tmpfile = crate::create_tempfile();

let db = Database::builder()
    .set_cache_size(1024 * 1024)
    .set_page_size(1024)
    .create(tmpfile.path())
    .unwrap();

let table_def: TableDefinition<u64, &[u8]> = TableDefinition::new("x");

let tx = db.begin_write().unwrap();
{
```

--------------------------------

### ReadableTableMetadata for Table

Source: https://docs.rs/redb/latest/src/redb/table.rs.html

Implementation of the ReadableTableMetadata trait for Table, providing methods to get table statistics and length.

```APIDOC
## ReadableTableMetadata for Table

### Description
Implementation of the ReadableTableMetadata trait for Table, providing methods to get table statistics and length.

### Methods

#### stats

##### Signature
fn stats(&self) -> Result<TableStats>

##### Description
Returns statistics about the table, including tree height, leaf pages, branch pages, stored leaf bytes, metadata bytes, and fragmented bytes.

##### Returns
- **Result<TableStats>** - Table statistics.

#### len

##### Signature
fn len(&self) -> Result<u64>

##### Description
Returns the number of key-value pairs in the table.

##### Returns
- **Result<u64>** - The number of entries in the table.
```

--------------------------------

### InMemoryBackend::new

Source: https://docs.rs/redb/latest/redb/backends/struct.InMemoryBackend.html

Creates a new, empty memory backend. This is the primary constructor for the InMemoryBackend struct.

```APIDOC
## InMemoryBackend::new

### Description
Creates a new, empty memory backend.

### Method
`pub fn new() -> Self`

### Parameters
None.

### Returns
- `Self` - A new `InMemoryBackend` instance.

### Example
```rust
let backend = InMemoryBackend::new();
```
```

--------------------------------

### ReadableTable for Table

Source: https://docs.rs/redb/latest/src/redb/table.rs.html

Implementation of the ReadableTable trait for Table, providing methods to get values by key and iterate over ranges.

```APIDOC
## ReadableTable for Table

### Description
Implementation of the ReadableTable trait for Table, providing methods to get values by key and iterate over ranges.

### Methods

#### get

##### Signature
fn get<'a>(&self, key: impl Borrow<K::SelfType<'a>>) -> Result<Option<AccessGuard<'_, V>>>

##### Description
Returns the value associated with the given key, if it exists.

##### Parameters
- **key** (impl Borrow<K::SelfType<'a>>) - Required - The key to look up.

##### Returns
- **Result<Option<AccessGuard<'_, V>>>** - An optional access guard to the value.

#### range

##### Signature
fn range(&self, range: impl KeyRange<K>) -> Result<Range<'_, K, V>>

##### Description
Returns an iterator over a range of key-value pairs.

##### Parameters
- **range** (impl KeyRange<K>) - Required - The range of keys to iterate over.

##### Returns
- **Result<Range<'_, K, V>>** - A range iterator.
```

--------------------------------

### Any Trait Implementation for MultimapRange

Source: https://docs.rs/redb/latest/redb/struct.MultimapRange.html

The blanket implementation of the `Any` trait for `MultimapRange`, providing the `type_id` method to get the type identifier.

```APIDOC
## Any Trait Implementation for MultimapRange

### Description
Provides the `Any` trait implementation for `MultimapRange`, allowing type inspection at runtime.

### Method: type_id

#### Signature
`fn type_id(&self) -> TypeId`

#### Description
Gets the `TypeId` of `self`.

#### Returns
- `TypeId` - The type identifier of the value.
```

--------------------------------

### Builder::new

Source: https://docs.rs/redb/latest/redb/struct.Builder.html

Constructs a new Builder with sensible defaults, including a cache size of 1GiB.

```APIDOC
## Builder::new

### Description
Construct a new Builder with sensible defaults.

### Method
`pub fn new() -> Self`

### Parameters
None.

### Returns
- `Self` - A new Builder instance.

### Defaults
- `cache_size_bytes`: 1GiB

```

--------------------------------

### Range::rfold

Source: https://docs.rs/redb/latest/redb/struct.Range.html

An iterator method that reduces the iterator's elements to a single, final value, starting from the back.

```APIDOC
## Range::rfold

### Description
An iterator method that reduces the iterator's elements to a single, final value, starting from the back.

### Method
rfold

### Signature
```rust
fn rfold<B, F>(self, init: B, f: F) -> B
where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B,
```

### Parameters
- `init` (B) - The initial value.
- `f` (F) - A closure that takes the accumulator and an element, returning a new accumulator.

### Returns
- `B` - The final reduced value.

### Notes
- This method is available on types that implement `DoubleEndedIterator`.
- It is const-unstable as of Rust 1.27.0.
```

--------------------------------

### Database::create

Source: https://docs.rs/redb/latest/redb/struct.Database.html

Creates a new database at the specified path, or opens an existing one if the file is a valid redb database. Returns an error if the file exists but is not a valid redb database.

```APIDOC
## Database::create

### Description
Opens the specified file as a redb database. If the file does not exist or is empty, a new database is initialized. If the file is a valid redb database, it is opened. Otherwise, an error is returned.

### Method
create

### Signature
`pub fn create(path: impl AsRef<Path>) -> Result<Database, DatabaseError>`

### Parameters
- **path** (impl AsRef<Path>) - Required - The file path to create or open the database.

### Returns
- **Result<Database, DatabaseError>** - On success, returns a `Database` instance. On failure, returns a `DatabaseError`.

### Example
```rust
use redb::*;
const TABLE: TableDefinition<u64, u64> = TableDefinition::new("my_data");

let db = Database::create(filename)?;
let write_txn = db.begin_write()?;
{
    let mut table = write_txn.open_table(TABLE)?;
    table.insert(&0, &0)?;
}
write_txn.commit()?;
```
```
Tokens:
Raw