Trait ReadableTable 

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

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

Required Methods

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

Returns the value corresponding to the given key

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

where KR: Borrow<<K as Value>::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>)>, StorageError>

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

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

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

Provided Methods

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

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".

Implementors

impl<K, V> ReadableTable<K, V> for ReadOnlyTable<K, V>

where K: Key + 'static, V: Value + 'static,

impl<K, V> ReadableTable<K, V> for Table<'_, K, V>

where K: Key + 'static, V: Value + 'static,