Struct OptimisticWriteTx

Source

pub struct OptimisticWriteTx { /* private fields */ }

Expand description

A cross-keyspace transaction using optimistic concurrency control

Use WriteTransaction::commit to commit changes to the keyspace(s).

Transactions keep a consistent view of the database at the time, meaning old data will not be dropped until it is not referenced by any active transaction.

For that reason, you should try to keep transactions short-lived, and make sure they are not held somewhere forever.

§Caution

The transaction may fail and have to be rerun if it conflicts.

Implementations§

Source §

impl WriteTransaction

Source

pub fn durability(self, mode: Option<PersistMode>) -> Self

Sets the durability level.

Source

pub fn take<K: Into<UserKey>>( &mut self, keyspace: impl AsRef<Keyspace>, key: K, ) -> Result<Option<UserValue>>

Removes an item and returns its value if it existed.

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

let mut tx = db.write_tx()?;

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

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

§Errors

Will return Err if an IO error occurs.

Source

pub fn update_fetch<K: Into<UserKey>, F: FnOnce(Option<&UserValue>) -> Option<UserValue>>( &mut self, keyspace: impl AsRef<Keyspace>, 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.

§Examples

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

let mut tx = db.write_tx()?;

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

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

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

let mut tx = db.write_tx()?;

let updated = tx.update_fetch(&tree, "a", |_| None)?;
assert!(updated.is_none());
tx.commit()?;

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

§Errors

Will return Err if an IO error occurs.

Source

pub fn fetch_update<K: Into<UserKey>, F: FnOnce(Option<&UserValue>) -> Option<UserValue>>( &mut self, keyspace: impl AsRef<Keyspace>, 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.

§Examples

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

let mut tx = db.write_tx()?;

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

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

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

let mut tx = db.write_tx()?;

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

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

§Errors

Will return Err if an IO error occurs.

Source

pub fn insert<K: Into<UserKey>, V: Into<UserValue>>( &mut self, keyspace: impl AsRef<Keyspace>, key: K, value: V, )

Inserts a key-value pair into the keyspace.

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.

§Examples

tree.insert("a", "previous_value")?;
assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());

let mut tx = db.write_tx()?;
tx.insert(&tree, "a", "new_value");

drop(tx);

// Write was not committed
assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());

Source

pub fn remove<K: Into<UserKey>>( &mut self, keyspace: impl AsRef<Keyspace>, key: K, )

Removes an item from the keyspace.

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

§Examples

tree.insert("a", "previous_value")?;
assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());

let mut tx = db.write_tx()?;
tx.remove(&tree, "a");

// Read-your-own-write
let item = tx.get(&tree, "a")?;
assert_eq!(None, item);

drop(tx);

// Deletion was not committed
assert_eq!(b"previous_value", &*tree.get("a")?.unwrap());