Add typed stores; use a dynamic Error type

Author: tomerfiliba

Cargo.lock

@@ -7,6 +7,7 @@ keywords = ["key-value", "persistent", "store"]
 description = "A lean, efficient and fast peristent in-process key-value store"
 
 [dependencies]
+databuf = "0.5.0"
 memmap = "0.7.0"
 simd-itertools = "0.2.3"
 siphasher = "1.0.1"

Cargo.toml

@@ -0,0 +1,18 @@
+use std::sync::Arc;
+
+use vicky_store::{Config, Result, VickyStore, VickyTypedStore};
+
+fn main() -> Result<()> {
+    let db = Arc::new(VickyStore::open("/tmp/vicky-dir", Config::default())?);
+
+    let typed = VickyTypedStore::<String, Vec<u32>>::new(db);
+    typed.insert("hello".into(), vec![1, 2, 3])?;
+
+    println!("{:?}", typed.get("hello")?); // Some([1, 2, 3])
+
+    typed.remove("hello")?;
+
+    println!("{:?}", typed.contains("hello")?); // false
+
+    Ok(())
+}

examples/typed.rs

@@ -1,8 +1,8 @@
 use std::hash::Hasher;
 
-use siphasher::sip128::SipHasher24;
+use siphasher::sip128::{Hash128, Hasher128, SipHasher24};
 
-use crate::{Error, Result};
+use crate::{Result, VickyError};
 
 #[derive(Debug, Clone, Copy)]
 pub struct SecretKey([u8; 16]);
@@ -17,7 +17,7 @@ impl SecretKey {
     pub fn new<B: AsRef<[u8]> + ?Sized>(key: &B) -> Result<Self> {
         let key = key.as_ref();
         if key.len() != Self::LEN {
-            return Err(Error::WrongSecretKeyLength);
+            return Err(Box::new(VickyError::WrongSecretKeyLength));
         }
         let mut bytes = [0u8; Self::LEN];
         bytes.copy_from_slice(&key);
@@ -34,14 +34,10 @@ pub(crate) struct PartedHash {
 
 pub(crate) const INVALID_SIG: u32 = 0;
 pub(crate) const USER_NAMESPACE: u8 = 1;
+//pub(crate) const TYPED_NAMESPACE: u8 = 2;
 
 impl PartedHash {
-    pub fn from_buffer(namespace: u8, key: &SecretKey, buf: &[u8]) -> Self {
-        // maybe use blake3?
-        let mut hasher = SipHasher24::new_with_key(&key.0);
-        hasher.write_u8(namespace);
-        hasher.write(buf);
-        let h = hasher.hash(buf);
+    fn from_hash(h: Hash128) -> Self {
         let mut signature = h.h1 as u32;
         if signature == INVALID_SIG {
             signature = h.h2 as u32;
@@ -58,27 +54,72 @@ impl PartedHash {
             signature,
         }
     }
+    pub fn from_buffer(namespace: u8, key: &SecretKey, buf: &[u8]) -> Self {
+        // maybe use blake3?
+        let mut hasher = SipHasher24::new_with_key(&key.0);
+        hasher.write_u8(namespace);
+        hasher.write(buf);
+        Self::from_hash(hasher.finish128())
+    }
+
+    #[allow(dead_code)]
+    pub fn builder(key: &SecretKey) -> PartedHashBuilder {
+        PartedHashBuilder(SipHasher24::new_with_key(&key.0))
+    }
+
+    #[allow(dead_code)]
+    pub fn to_u64(&self) -> u64 {
+        ((self.shard_selector as u64) << 48)
+            | ((self.row_selector as u64) << 32)
+            | (self.signature as u64)
+    }
+}
+
+#[allow(dead_code)]
+pub(crate) struct PartedHashBuilder(SipHasher24);
+
+impl PartedHashBuilder {
+    #[allow(dead_code)]
+    pub fn write(mut self, bytes: &[u8]) -> Self {
+        self.0.write(bytes);
+        self
+    }
+    #[allow(dead_code)]
+    pub fn write_u32(mut self, v: u32) -> Self {
+        self.0.write_u32(v);
+        self
+    }
+    #[allow(dead_code)]
+    pub fn write_u8(mut self, v: u8) -> Self {
+        self.0.write_u8(v);
+        self
+    }
+    #[allow(dead_code)]
+    pub fn finish(self) -> PartedHash {
+        PartedHash::from_hash(self.0.finish128())
+    }
 }
 
 #[test]
 fn test_parted_hash() -> Result<()> {
-    assert!(matches!(
-        SecretKey::new("1234"),
-        Err(Error::WrongSecretKeyLength)
-    ));
-    assert!(matches!(
-        SecretKey::new("12341234123412341"),
-        Err(Error::WrongSecretKeyLength)
-    ));
+    SecretKey::new("1234").expect_err("shouldn't work");
+    SecretKey::new("12341234123412341").expect_err("shouldn't work");
+
     let key = SecretKey::new("aaaabbbbccccdddd")?;
 
     assert_eq!(
-        PartedHash::from_buffer(USER_NAMESPACE, &key, b"hello world"),
-        PartedHash {
-            shard_selector: 62379,
-            row_selector: 17802,
-            signature: 3217405680
-        }
+        PartedHash::from_buffer(USER_NAMESPACE, &key, b"hello world").to_u64(),
+        12143172433256666175,
     );
+
+    assert_eq!(
+        PartedHash::builder(&key)
+            .write_u8(USER_NAMESPACE)
+            .write(b"hello world")
+            .finish()
+            .to_u64(),
+        12143172433256666175,
+    );
+
     Ok(())
 }

src/hashing.rs

@@ -3,41 +3,37 @@
 mod hashing;
 mod shard;
 mod store;
+mod typed;
 
 pub use hashing::SecretKey;
 use std::fmt::{Display, Formatter};
 pub use store::{Stats, VickyStore};
+pub use typed::{VickyTypedKey, VickyTypedStore};
 
 #[derive(Debug)]
-pub enum Error {
+pub enum VickyError {
     WrongSecretKeyLength,
     KeyTooLong,
     ValueTooLong,
     KeyNotFound,
-    IOError(std::io::Error),
 }
 
-impl From<std::io::Error> for Error {
-    fn from(value: std::io::Error) -> Self {
-        Self::IOError(value)
-    }
-}
-
-impl Display for Error {
+impl Display for VickyError {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         match self {
-            Error::WrongSecretKeyLength => write!(f, "wrong secret length"),
-            Error::KeyTooLong => write!(f, "key too long"),
-            Error::KeyNotFound => write!(f, "key not found"),
-            Error::ValueTooLong => write!(f, "value too long"),
-            Error::IOError(err) => write!(f, "IO error: {err}"),
+            Self::WrongSecretKeyLength => write!(f, "wrong secret length"),
+            Self::KeyTooLong => write!(f, "key too long"),
+            Self::KeyNotFound => write!(f, "key not found"),
+            Self::ValueTooLong => write!(f, "value too long"),
         }
     }
 }
 
-impl std::error::Error for Error {}
+impl std::error::Error for VickyError {}
 
-pub type Result<T> = std::result::Result<T, Error>;
+/// It is an alias for a boxed [std::error::Error].
+pub type Error = Box<dyn std::error::Error + Send + Sync>;
+pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 /// The configuration options for VickyStore. Comes with sane defaults, feel free to use them
 #[derive(Debug, Clone)]