stupid-simple-kv 0.1.0

A dead-simple, pluggable, binary-sorted key-value store for Rust with FoundationDB-style keys. In-memory and SQLite backends. Zero-boilerplate and easy iteration.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! Crate root for stupid-simple-kv: a pluggable, minimal key-value store library.

pub mod keys;

pub mod storages {
    pub mod kv_backend;
    pub mod memory_backend;
    #[cfg(feature = "sqlite")]
    pub mod sqlite_backend;
}

pub mod utils {
    pub mod list_builder;
    pub use list_builder::KvListBuilder;
}

pub use keys::{Key, DecodeError, FromKey, IntoKey};
pub use storages::kv_backend::{KvBackend, KvResult};
pub use storages::memory_backend::MemoryBackend;
pub use utils::KvListBuilder;

/// The main `Kv` type providing simple get/set/delete/clear/key/list operations on a pluggable backend.
pub struct Kv<B: KvBackend> {
    backend: B,
}

impl<B: KvBackend> Kv<B> {
    /// Create a new key-value store instance with the provided backend.
    pub fn new(backend: B) -> Self {
        Self { backend }
    }
    /// Set a value for a key.
    pub fn set<K, T>(&mut self, key: K, value: T) -> KvResult<()>
    where
        K: IntoKey,
        T: bincode::Encode,
    {
        let key = key.into_key();
        let bytes = bincode::encode_to_vec(value, bincode::config::standard())?;
        self.backend.set(key, bytes)
    }
    /// Retrieve a value for a key.
    pub fn get<K, T>(&self, key: K) -> KvResult<Option<T>>
    where
        K: IntoKey,
        T: bincode::Decode<()>,
    {
        let key = key.into_key();
        match self.backend.get(&key)? {
            Some(bytes) => Ok(
                bincode::decode_from_slice(&bytes, bincode::config::standard())
                    .ok()
                    .map(|(value, _)| value),
            ),
            None => Ok(None),
        }
    }
    /// Delete a value for a key.
    pub fn delete<K>(&mut self, key: K) -> KvResult<()>
    where
        K: IntoKey,
    {
        let key = key.into_key();
        self.backend.delete(&key)
    }
    /// Remove all data.
    pub fn clear(&mut self) -> KvResult<()> {
        self.backend.clear()
    }
    /// Return an iterator over all keys.
    pub fn keys(&self) -> KvResult<impl Iterator<Item = Key> + '_> {
        self.backend.keys()
    }
    /// Create a list builder for filtered/ordered iteration.
    pub fn list<T>(&self) -> KvListBuilder<B, T> {
        KvListBuilder::new(&self.backend)
    }
}

#[cfg(test)]
mod tests;