Struct Table 

pub struct Table<'txn, K: Key + 'static, V: Value + 'static> { /* private fields */ }

A table containing key-value mappings

Implementations

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

pub fn get_mut<'k>( &mut self, key: impl Borrow<K::SelfType<'k>>, ) -> Result<Option<AccessGuardMut<'_, V>>>

Returns an accessor, which allows mutation, to the value corresponding to the given key

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

Removes and returns the first key-value pair in the table

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

Removes and returns the last key-value pair in the table

pub fn extract_if<F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool>( &mut self, predicate: F, ) -> Result<ExtractIf<'_, K, V, F>>

Applies predicate to all key-value pairs. All entries for which predicate evaluates to true are returned in an iterator, and those which are read from the iterator are removed

Note: values not read from the iterator will not be removed

pub fn extract_from_if<'a, KR, F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool>( &mut self, range: impl RangeBounds<KR> + 'a, predicate: F, ) -> Result<ExtractIf<'_, K, V, F>>

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

Applies predicate to all key-value pairs in the specified range. All entries for which predicate evaluates to true are returned in an iterator, and those which are read from the iterator are removed

Note: values not read from the iterator will not be removed

pub fn retain<F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool>( &mut self, predicate: F, ) -> Result

Applies predicate to all key-value pairs. All entries for which predicate evaluates to false are removed.

pub fn retain_in<'a, KR, F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool>( &mut self, range: impl RangeBounds<KR> + 'a, predicate: F, ) -> Result

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

Applies predicate to all key-value pairs in the range start..end. All entries for which predicate evaluates to false are removed.

pub fn insert<'k, 'v>( &mut self, key: impl Borrow<K::SelfType<'k>>, value: impl Borrow<V::SelfType<'v>>, ) -> Result<Option<AccessGuard<'_, V>>>

Insert mapping of the given key to the given value

If key is already present it is replaced

Returns the old value, if the key was present in the table, otherwise None is returned

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

Removes the given key

Returns the old value, if the key was present in the table

pub fn insert_bulk<'i, I>(&mut self, items: I, sorted: bool) -> Result<usize>

where I: IntoIterator<Item = (K::SelfType<'i>, V::SelfType<'i>)>,

Bulk insert optimized for loading large datasets

This method provides significant performance improvements over individual insert() calls for bulk data loading scenarios.

Arguments

• items - Iterator of (key, value) pairs to insert
• sorted - Hint indicating whether items are already sorted by key. Set to true if you know the data is sorted for optimal performance.

Performance

• Sorted data: 2-3x faster than individual inserts (uses optimized bulk construction)
• Unsorted data: 1.5-2x faster than individual inserts (uses batched insertion with sorting)

Returns

Returns the total number of items inserted

Errors

Returns an error if:

• Any key or value exceeds maximum size limits
• Storage errors occur during insertion

Examples

// Pre-sorted data (best performance)
let sorted_data = vec![(1u64, "one"), (2u64, "two"), (3u64, "three")];
let count = table.insert_bulk(sorted_data.into_iter(), true)?;

// Unsorted data (still faster than individual inserts)
let unsorted_data = vec![(10u64, "ten"), (5u64, "five"), (7u64, "seven")];
let count = table.insert_bulk(unsorted_data.into_iter(), false)?;

pub fn remove_bulk<'i, I>(&mut self, keys: I) -> Result<usize>

where I: IntoIterator<Item = K::SelfType<'i>>,

Bulk remove optimized for deleting multiple keys

This method provides performance improvements over individual remove() calls when deleting many keys at once.

Arguments

• keys - Iterator of keys to remove

Returns

Returns the number of keys that were actually removed (keys that existed in the table)

Examples

let keys_to_delete = vec![1u64, 2u64, 3u64, 4u64, 5u64];
let removed_count = table.remove_bulk(keys_to_delete.into_iter())?;

impl<K: Key + 'static, V: MutInPlaceValue + 'static> Table<'_, K, V>

pub fn insert_reserve<'a>( &mut self, key: impl Borrow<K::SelfType<'a>>, value_length: usize, ) -> Result<AccessGuardMutInPlace<'_, V>>

Reserve space to insert a key-value pair

If key is already present it is replaced

The returned reference will have length equal to value_length

Trait Implementations

impl<K: Key + 'static, V: Value + 'static> Debug for Table<'_, K, V>

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

Formats the value using the given formatter.

impl<K: Key + 'static, V: Value + 'static> Drop for Table<'_, K, V>

fn drop(&mut self)

Executes the destructor for this type.

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

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

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

fn get_bulk<'i, I>(&self, keys: I) -> Result<Vec<Option<AccessGuard<'_, V>>>>

where I: IntoIterator<Item = K::SelfType<'i>>,

Retrieves multiple values in a single batch operation.

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

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

impl<K: Key + 'static, V: Value + 'static> ReadableTableMetadata for Table<'_, K, V>

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

Retrieves information about storage usage for the table

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

Returns the number of entries in the table

fn is_empty(&self) -> Result<bool>

Returns true if the table is empty

impl<K: Key + 'static, V: Value + 'static> TableHandle for Table<'_, K, V>

fn name(&self) -> &str