Trait ReadableTable

pub trait ReadableTable<K: Key + 'static, V: Value + 'static>: ReadableTableMetadata {
    // Required methods
    fn get<'a>(
        &self,
        key: impl Borrow<K::SelfType<'a>>,
    ) -> Result<Option<AccessGuard<'_, V>>>;
    fn range<'a, KR>(
        &self,
        range: impl RangeBounds<KR> + 'a,
    ) -> Result<Range<'_, K, V>>
       where KR: Borrow<K::SelfType<'a>> + 'a;
    fn first(&self) -> Result<Option<(AccessGuard<'_, K>, AccessGuard<'_, V>)>>;
    fn last(&self) -> Result<Option<(AccessGuard<'_, K>, AccessGuard<'_, V>)>>;

    // Provided method
    fn iter(&self) -> Result<Range<'_, K, V>> { ... }
}

Required Methods

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

Returns the value corresponding to the given key

fn range<'a, KR>( &self, range: impl RangeBounds<KR> + 'a, ) -> Result<Range<'_, K, V>>

where KR: Borrow<K::SelfType<'a>> + 'a,

Returns a double-ended iterator over a range of elements in the table

Examples

Usage:

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());

fn first(&self) -> Result<Option<(AccessGuard<'_, K>, AccessGuard<'_, V>)>>

Returns the first key-value pair in the table, if it exists

fn last(&self) -> Result<Option<(AccessGuard<'_, K>, AccessGuard<'_, V>)>>

Returns the last key-value pair in the table, if it exists

Provided Methods

fn iter(&self) -> Result<Range<'_, K, V>>

Returns a double-ended iterator over all elements in the table

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'txn, K: Key + 'static, V: Value + 'static> ReadableTable<K, V> for Table<'txn, K, V>

impl<K: Key + 'static, V: Value + 'static> ReadableTable<K, V> for ReadOnlyTable<K, V>