+redb

examples/disk-read-file/main.rs

···
 extern crate repo_stream;
 use clap::Parser;
-use repo_stream::disk::SqliteStore;
+use repo_stream::disk::RedbStore;
 use repo_stream::drive::Processable;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
···
         match repo_stream::drive::load_car(reader, |block| S(block.len()), 1024).await? {
             repo_stream::drive::Vehicle::Lil(_, _) => panic!("try this on a bigger car"),
             repo_stream::drive::Vehicle::Big(big_stuff) => {
-                let disk_store = SqliteStore::new(tmpfile);
+                let disk_store = RedbStore::new(tmpfile);
                 let (commit, driver) = big_stuff.finish_loading(disk_store).await?;
                 log::warn!("big: {:?}", commit);
                 driver

src/disk.rs

···
+use redb::ReadableDatabase;
 use rusqlite::OptionalExtension;
 use std::error::Error;
 use std::path::PathBuf;
···
     fn get(&mut self, key: Vec<u8>) -> Result<Option<Vec<u8>>, Self::StorageError>;
 }
 
-/////////////////
+///////////////// sqlite
 
 pub struct SqliteStore {
     path: PathBuf,
···
     }
 }
 
-// /// The main storage interface for MST blocks
-// ///
-// /// **Note**: `get` and `put` are **synchronous methods that may block**
-// pub trait BlockStore<T: Clone> {
-//     fn get(&self, cid: Cid) -> Option<MaybeProcessedBlock<T>>;
-//     fn put(&mut self, cid: Cid, mpb: MaybeProcessedBlock<T>);
-// }
+//////////// redb why not
+
+const REDB_TABLE: redb::TableDefinition<&[u8], &[u8]> = redb::TableDefinition::new("blocks");
+
+pub struct RedbStore {
+    path: PathBuf,
+}
+
+impl RedbStore {
+    pub fn new(path: PathBuf) -> Self {
+        Self { path }
+    }
+}
+
+impl StorageErrorBase for redb::Error {}
+
+impl DiskStore for RedbStore {
+    type StorageError = redb::Error;
+    type Access = RedbAccess;
+    async fn get_access(&mut self) -> Result<RedbAccess, redb::Error> {
+        let path = self.path.clone();
+        let db = tokio::task::spawn_blocking(move || {
+            let db = redb::Database::create(path)?;
+            Ok::<_, Self::StorageError>(db)
+        })
+        .await
+        .expect("join error")?;
+
+        Ok(RedbAccess { db })
+    }
+}
+
+pub struct RedbAccess {
+    db: redb::Database,
+}
 
-// ///// wheee
+impl DiskAccess for RedbAccess {
+    type StorageError = redb::Error;
+    fn get_writer(&mut self) -> Result<impl DiskWriter<redb::Error>, redb::Error> {
+        let mut tx = self.db.begin_write()?;
+        tx.set_durability(redb::Durability::None)?;
+        Ok(RedbWriter { tx: Some(tx) })
+    }
+    fn get_reader(&self) -> Result<impl DiskReader<StorageError = redb::Error>, redb::Error> {
+        let tx = self.db.begin_read()?;
+        Ok(RedbReader { tx })
+    }
+}
 
-// /// In-memory MST block storage
-// ///
-// /// a thin wrapper around a hashmap
-// pub struct MemoryStore<T: Clone> {
-//     map: HashMap<Cid, MaybeProcessedBlock<T>>,
-// }
+pub struct RedbWriter {
+    tx: Option<redb::WriteTransaction>,
+}
 
-// impl<T: Clone> BlockStore<T> for MemoryStore<T> {
-//     fn get(&self, cid: Cid) -> Option<MaybeProcessedBlock<T>> {
-//         self.map.get(&cid).map(|t| t.clone())
-//     }
-//     fn put(&mut self, cid: Cid, mpb: MaybeProcessedBlock<T>) {
-//         self.map.insert(cid, mpb);
-//     }
-// }
+impl DiskWriter<redb::Error> for RedbWriter {
+    fn put(&mut self, key: Vec<u8>, val: Vec<u8>) -> Result<(), redb::Error> {
+        let mut table = self.tx.as_ref().unwrap().open_table(REDB_TABLE)?;
+        table.insert(&*key, &*val)?;
+        Ok(())
+    }
+}
 
-// //// the fun bits
+/// oops careful in async
+impl Drop for RedbWriter {
+    fn drop(&mut self) {
+        let tx = self.tx.take();
+        tx.unwrap().commit().unwrap();
+    }
+}
 
-// pub struct HybridStore<T: Clone, D: DiskStore> {
-//     mem: MemoryStore<T>,
-//     disk: D,
-// }
+pub struct RedbReader {
+    tx: redb::ReadTransaction,
+}
 
-// impl<T: Clone, D: DiskStore> BlockStore<T> for HybridStore<T, D> {
-//     fn get(&self, _cid: Cid) -> Option<MaybeProcessedBlock<T>> { todo!() }
-//     fn put(&mut self, _cid: Cid, _mpb: MaybeProcessedBlock<T>) { todo!() }
-// }
+impl DiskReader for RedbReader {
+    type StorageError = redb::Error;
+    fn get(&mut self, key: Vec<u8>) -> Result<Option<Vec<u8>>, redb::Error> {
+        let table = self.tx.open_table(REDB_TABLE)?;
+        let rv = table.get(&*key)?.map(|guard| guard.value().to_vec());
+        Ok(rv)
+    }
+}