Struct TransactionalPartitionHandle

pub struct TransactionalPartitionHandle { /* private fields */ }

Access to a partition of a transactional keyspace

Implementations

impl TransactionalPartitionHandle

pub fn path(&self) -> PathBuf

Returns the underlying LSM-tree’s path

pub fn take<K: Into<UserKey>>(&self, key: K) -> Result<Option<UserValue>>

Removes an item and returns its value if it existed.

The operation will run wrapped in a transaction.

partition.insert("a", "abc")?;

let taken = partition.take("a")?.unwrap();
assert_eq!(b"abc", &*taken);

let item = partition.get("a")?;
assert!(item.is_none());

Errors

Will return Err if an IO error occurs.

pub fn fetch_update<K: Into<UserKey>, F: FnMut(Option<&UserValue>) -> Option<UserValue>>( &self, key: K, f: F, ) -> Result<Option<UserValue>>

Atomically updates an item and returns the previous value.

Returning None removes the item if it existed before.

The operation will run wrapped in a transaction.

Note

The provided closure can be called multiple times as this function automatically retries on conflict. Since this is an FnMut, make sure it is idempotent and will not cause side-effects.

Examples

partition.insert("a", "abc")?;

let prev = partition.fetch_update("a", |_| Some(Slice::from(*b"def")))?.unwrap();
assert_eq!(b"abc", &*prev);

let item = partition.get("a")?;
assert_eq!(Some("def".as_bytes().into()), item);

partition.insert("a", "abc")?;

let prev = partition.fetch_update("a", |_| None)?.unwrap();
assert_eq!(b"abc", &*prev);

let item = partition.get("a")?;
assert!(item.is_none());

Errors

Will return Err if an IO error occurs.

pub fn update_fetch<K: Into<UserKey>, F: FnMut(Option<&UserValue>) -> Option<UserValue>>( &self, key: K, f: F, ) -> Result<Option<UserValue>>

Atomically updates an item and returns the new value.

Returning None removes the item if it existed before.

The operation will run wrapped in a transaction.

Note

The provided closure can be called multiple times as this function automatically retries on conflict. Since this is an FnMut, make sure it is idempotent and will not cause side-effects.

Examples

partition.insert("a", "abc")?;

let updated = partition.update_fetch("a", |_| Some(Slice::from(*b"def")))?.unwrap();
assert_eq!(b"def", &*updated);

let item = partition.get("a")?;
assert_eq!(Some("def".as_bytes().into()), item);

partition.insert("a", "abc")?;

let updated = partition.update_fetch("a", |_| None)?;
assert!(updated.is_none());

let item = partition.get("a")?;
assert!(item.is_none());

Errors

Will return Err if an IO error occurs.

pub fn insert<K: Into<UserKey>, V: Into<UserValue>>( &self, key: K, value: V, ) -> Result<()>

Inserts a key-value pair into the partition.

Keys may be up to 65536 bytes long, values up to 2^32 bytes. Shorter keys and values result in better performance.

If the key already exists, the item will be overwritten.

The operation will run wrapped in a transaction.

Examples

partition.insert("a", "abc")?;

assert!(!keyspace.read_tx().is_empty(&partition)?);

Errors

Will return Err if an IO error occurs.

pub fn remove<K: Into<UserKey>>(&self, key: K) -> Result<()>

Removes an item from the partition.

The key may be up to 65536 bytes long. Shorter keys result in better performance.

The operation will run wrapped in a transaction.

Examples

partition.insert("a", "abc")?;
assert!(!keyspace.read_tx().is_empty(&partition)?);

partition.remove("a")?;
assert!(keyspace.read_tx().is_empty(&partition)?);

Errors

Will return Err if an IO error occurs.

pub fn get<K: AsRef<[u8]>>(&self, key: K) -> Result<Option<UserValue>>

Retrieves an item from the partition.

The operation will run wrapped in a read snapshot.

Examples

partition.insert("a", "my_value")?;

let item = partition.get("a")?;
assert_eq!(Some("my_value".as_bytes().into()), item);

Errors

Will return Err if an IO error occurs.

pub fn size_of<K: AsRef<[u8]>>(&self, key: K) -> Result<Option<u32>>

Retrieves the size of an item from the partition.

The operation will run wrapped in a read snapshot.

Examples

partition.insert("a", "my_value")?;

let len = partition.size_of("a")?.unwrap_or_default();
assert_eq!("my_value".len() as u32, len);

Errors

Will return Err if an IO error occurs.

pub fn first_key_value(&self) -> Result<Option<KvPair>>

Returns the first key-value pair in the partition. The key in this pair is the minimum key in the partition.

The operation will run wrapped in a read snapshot.

Examples

partition.insert("a", "my_value")?;
partition.insert("b", "my_value")?;

assert_eq!(b"a", &*partition.first_key_value()?.unwrap().0);

Errors

Will return Err if an IO error occurs.

pub fn last_key_value(&self) -> Result<Option<KvPair>>

Returns the last key-value pair in the partition. The key in this pair is the maximum key in the partition.

The operation will run wrapped in a read snapshot.

Examples

partition.insert("a", "my_value")?;
partition.insert("b", "my_value")?;

assert_eq!(b"b", &*partition.last_key_value()?.unwrap().0);

Errors

Will return Err if an IO error occurs.

pub fn contains_key<K: AsRef<[u8]>>(&self, key: K) -> Result<bool>

Returns true if the partition contains the specified key.

The operation will run wrapped in a read snapshot.

Examples

partition.insert("a", "my_value")?;

assert!(partition.contains_key("a")?);
assert!(!partition.contains_key("b")?);

Errors

Will return Err if an IO error occurs.

Trait Implementations

impl Clone for TransactionalPartitionHandle

fn clone(&self) -> TransactionalPartitionHandle

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl GarbageCollection for TransactionalPartitionHandle

fn gc_scan(&self) -> Result<GcReport>

Collects statistics about blob fragmentation inside the partition.

fn gc_with_space_amp_target(&self, factor: f32) -> Result<u64>

Rewrites blobs in order to achieve the given space amplification factor.

fn gc_with_staleness_threshold(&self, threshold: f32) -> Result<u64>

Rewrites blobs that have reached a given staleness threshold.

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

Drops fully stale segments.