Crate kv

Expand description

kv is a simple way to embed a key/value store in Rust applications. It is built using sled and aims to be as lightweight as possible while still providing a nice high level interface.

§Getting started

use kv::*;

#[derive(serde::Serialize, serde::Deserialize, PartialEq)]
struct SomeType {
    a: i32,
    b: i32
}

fn run() -> Result<(), Error> {
    // Configure the database
    let mut cfg = Config::new("./test/example1");

    // Open the key/value store
    let store = Store::new(cfg)?;

    // A Bucket provides typed access to a section of the key/value store
    let test = store.bucket::<Raw, Raw>(Some("test"))?;

    let key = Raw::from(b"test");
    let value = Raw::from(b"123");

    // Set test = 123
    test.set(&key, &value)?;
    assert!(test.get(&key).unwrap().unwrap() == value);
    assert!(test.get(&b"something else".into()).unwrap() == None);

    // Integer keys
    let aaa = store.bucket::<Integer, String>(Some("aaa"))?;
    let key = Integer::from(1);
    let value = String::from("Testing");
    aaa.set(&key, &value);

    #[cfg(feature = "json-value")]
    {
        // Using a Json encoded type is easy, thanks to Serde
        let bucket = store.bucket::<&str, Json<SomeType>>(None)?;

        let k = "example";
        let x = Json(SomeType {a: 1, b: 2});
        bucket.set(&k, &x)?;

        let x: Json<SomeType> = bucket.get(&k)?.unwrap();

        for item in bucket.iter() {
            let item = item?;
            let key: String = item.key()?;
            let value = item.value::<Json<SomeType>>()?;
            println!("key: {}, value: {}", key, value);
        }

        // A transaction
        bucket.transaction(|txn| {
            txn.set(&"x", &Json(SomeType {a: 1, b: 2}))?;
            txn.set(&"y", &Json(SomeType {a: 3, b: 4}))?;
            txn.set(&"z", &Json(SomeType {a: 5, b: 6}))?;

            Ok(())
        })?;
    }
    Ok(())
}

Macros§

codec: Define a codec type and implement the Codec trait

Structs§

Batch: Batch update
Bincode: Codec implementation
Bucket: Provides typed access to the key/value store
Config: Config is used to create a new store
Integer: Integer key type
Item: Key/value pair
Iter: Iterator over Bucket keys and values
Json: Codec implementation
Lexpr: Codec implementation
Msgpack: Codec implementation
Store: Store is used to read/write data to disk using sled
Transaction: Transaction
Watch: Subscribe to key updated

Enums§

Error: Error type
Event: Event is used to describe the type of update

Traits§

Codec: Base trait for values that can be encoded using serde
Key: A Key can be used as a key to a database
Value: A trait used to convert between types and Raw

Functions§

abort: Abort a transaction

Type Aliases§

Raw: Raw is an alias for sled::IVec
TransactionError: Transaction error

Crate kvCopy item path