Struct SingleWriterWriteTx

Source

pub struct SingleWriterWriteTx<'a> { /* private fields */ }

Expand description

A single-writer (serialized) cross-keyspace transaction

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.

Implementations§

Source §

impl<'tx> WriteTransaction<'tx>

Source

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

Sets the durability level.

Source

pub fn take<K: Into<UserKey>>( &mut self, keyspace: &SingleWriterTxKeyspace, 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: &SingleWriterTxKeyspace, 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: &SingleWriterTxKeyspace, 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: &SingleWriterTxKeyspace, key: K, value: V, )

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: &SingleWriterTxKeyspace, 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());