sled is a high-performance embedded database with
an API that is similar to a
but with several additional capabilities for
assisting creators of stateful systems.
It is fully thread-safe, and all operations are
Trees are supported with the
ACID transactions involving reads and writes to
multiple items are supported with the
method. Transactions may also operate over
docs for more info).
Users may also subscribe to updates on individual
Trees by using the
method, which returns a blocking
updates to keys that begin with the provided
prefix. You may supply an empty prefix to subscribe
(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.
method, you may "push" data to a
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.
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));
A batch of updates that will be applied atomically to the Tree.
Top-level configuration for the system.
A buffer that may either be inline or remote and protected by an Arc
An iterator over keys and values in a
A subscriber listening on a specified prefix
A transaction that will be applied atomically to the Tree.
A flash-sympathetic persistent lock-free B+ tree
An Error type encapsulating various issues that may come up
in both the expected and unexpected operation of a
An event that happened to a key that a subscriber is interested in.
Allows arbitrary logic to be injected into mere operations of the
The top-level result type for dealing with