sled 0.26.3

a modern embedded database

sled is a high-performance embedded database with an API that is similar to a BTreeMap<[u8], [u8]>, but with several additional capabilities for assisting creators of stateful systems.

It is fully thread-safe, and all operations are atomic. Multiple Trees are supported with the Db::open_tree method.

ACID transactions involving reads and writes to multiple items are supported with the Tree::transaction method. Transactions may also operate over multiple Trees (see Tree::transaction docs for more info).

Users may also subscribe to updates on individual Trees by using the Tree::watch_prefix method, which returns a blocking Iterator over updates to keys that begin with the provided prefix. You may supply an empty prefix to subscribe to everything.

Merge operators (aka read-modify-write operators) are supported. A merge operator is a function that specifies how new data can be merged into an existing value without requiring both a read and a write. Using the Tree::merge method, you may "push" data to a Tree value and have the provided merge operator combine it with the existing value, if there was one. They are set on a per-Tree basis, and essentially allow any sort of data structure to be built using merges as an atomic high-level operation.

sled is built by experienced database engineers who think users should spend less time tuning and working against high-friction APIs. Expect significant ergonomic and performance improvements over time. Most surprises are bugs, so please let us know if something is high friction.

Examples

use sled::Db;

let t = Db::open("my_db").unwrap();
t.insert(b"yo!", b"v1");
assert_eq!(&t.get(b"yo!").unwrap().unwrap(), b"v1");

// Atomic compare-and-swap.
t.cas(
b"yo!",       // key
Some(b"v1"),  // old value, None for not present
Some(b"v2"),  // new value, None for delete
).unwrap();

// Iterates over key-value pairs, starting at the given key.
let scan_key: &[u8] = b"a non-present key before yo!";
let mut iter = t.range(scan_key..);
assert_eq!(&iter.next().unwrap().unwrap().0, b"yo!");
assert_eq!(iter.next(), None);

t.remove(b"yo!");
assert_eq!(t.get(b"yo!"), Ok(None));