implement db trait without wrappers

10 files changed, 61 insertions, 71 deletions

diff --git a/database/src/backends/memory.rs b/database/src/backends/memory.rs
index d7d0e2c..0c1635f 100644
--- a/database/src/backends/memory.rs
+++ b/database/src/backends/memory.rs
@@ -4,30 +4,31 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use crate::backends::{Db, ReadTransaction, ReadTxnFunction, WriteTransaction, WriteTxnFunction};
+use crate::backends::{
+    Database, ReadTransaction, ReadTxnFunction, WriteTransaction, WriteTxnFunction,
+};
 use anyhow::Result;
 use std::{
     collections::BTreeMap,
     sync::{RwLock, RwLockReadGuard, RwLockWriteGuard},
 };
 
-type Inner = BTreeMap<Vec<u8>, Vec<u8>>;
-pub struct Memory(RwLock<BTreeMap<Vec<u8>, Vec<u8>>>);
+type MemdbInner = BTreeMap<Vec<u8>, Vec<u8>>;
+type Memdb = RwLock<MemdbInner>;
 
-impl Memory {
-    pub fn new() -> Self {
-        Self(RwLock::new(BTreeMap::new()))
-    }
+pub fn new() -> Memdb {
+    Memdb::default()
 }
-impl Db for Memory {
+
+impl Database for Memdb {
     fn write_transaction(&self, f: &mut WriteTxnFunction) -> Result<()> {
-        f(&mut self.0.write().unwrap())
+        f(&mut self.write().unwrap())
     }
     fn read_transaction(&self, f: &mut ReadTxnFunction) -> Result<()> {
-        f(&self.0.read().unwrap())
+        f(&self.read().unwrap())
     }
 }
-impl WriteTransaction for RwLockWriteGuard<'_, Inner> {
+impl WriteTransaction for RwLockWriteGuard<'_, MemdbInner> {
     fn set(&mut self, key: &[u8], value: &[u8]) -> Result<()> {
         (**self).insert(key.to_vec(), value.to_vec());
         Ok(())
@@ -37,7 +38,7 @@ impl WriteTransaction for RwLockWriteGuard<'_, Inner> {
         Ok(())
     }
 }
-impl ReadTransaction for RwLockWriteGuard<'_, Inner> {
+impl ReadTransaction for RwLockWriteGuard<'_, MemdbInner> {
     fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
         Ok((**self).get(key).cloned())
     }
@@ -53,7 +54,7 @@ impl ReadTransaction for RwLockWriteGuard<'_, Inner> {
         })
     }
 }
-impl ReadTransaction for RwLockReadGuard<'_, Inner> {
+impl ReadTransaction for RwLockReadGuard<'_, MemdbInner> {
     fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
         Ok((**self).get(key).cloned())
     }
diff --git a/database/src/backends/mod.rs b/database/src/backends/mod.rs
index 580548e..4cbb4cf 100644
--- a/database/src/backends/mod.rs
+++ b/database/src/backends/mod.rs
@@ -4,18 +4,17 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-pub mod memory;
-pub mod redb;
-pub mod rocksdb;
+mod memory;
+mod redb;
+mod rocksdb;
 
-use crate::backends::{memory::Memory, redb::Redb, rocksdb::Rocksdb};
 use anyhow::{Result, bail};
 use std::{path::Path, sync::Arc};
 
 pub type WriteTxnFunction = dyn FnMut(&mut dyn WriteTransaction) -> Result<()>;
 pub type ReadTxnFunction = dyn FnMut(&dyn ReadTransaction) -> Result<()>;
 
-pub trait Db {
+pub trait Database {
     fn write_transaction(&self, f: &mut WriteTxnFunction) -> Result<()>;
     fn read_transaction(&self, f: &mut ReadTxnFunction) -> Result<()>;
 }
@@ -32,11 +31,11 @@ pub trait ReadTransaction {
     ) -> Result<Box<dyn Iterator<Item = Result<Vec<u8>>> + 'a>>;
 }
 
-pub fn create_backend(driver: &str, path: &Path) -> Result<Arc<dyn Db>> {
+pub fn create_backend(driver: &str, path: &Path) -> Result<Arc<dyn Database>> {
     Ok(match driver {
-        "rocksdb" => Arc::new(Rocksdb::new(path)?),
-        "redb" => Arc::new(Redb::new(path)?),
-        "memory" => Arc::new(Memory::new()),
+        "rocksdb" => Arc::new(rocksdb::new(path)?),
+        "redb" => Arc::new(redb::new(path)?),
+        "memory" => Arc::new(memory::new()),
         _ => bail!("unknown db driver"),
     })
 }
diff --git a/database/src/backends/redb.rs b/database/src/backends/redb.rs
index d1a0f8c..70623b5 100644
--- a/database/src/backends/redb.rs
+++ b/database/src/backends/redb.rs
@@ -4,50 +4,48 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use crate::backends::{Db, ReadTransaction, ReadTxnFunction, WriteTransaction, WriteTxnFunction};
+use crate::backends::{
+    Database, ReadTransaction, ReadTxnFunction, WriteTransaction, WriteTxnFunction,
+};
 use anyhow::Result;
-use redb::{AccessGuard, Database, ReadableDatabase, ReadableTable, StorageError, TableDefinition};
+use redb::{AccessGuard, ReadableDatabase, ReadableTable, StorageError, Table, TableDefinition};
 use std::path::Path;
 
-pub struct Redb {
-    db: Database,
-}
-
 const TABLE: TableDefinition<&[u8], &[u8]> = TableDefinition::new("kv");
 
-impl Redb {
-    pub fn new(path: &Path) -> Result<Self> {
-        Ok(Self {
-            db: Database::create(path)?,
-        })
-    }
+pub fn new(path: &Path) -> Result<redb::Database> {
+    Ok(redb::Database::create(path)?)
 }
-impl Db for Redb {
+
+impl Database for redb::Database {
     fn write_transaction(&self, f: &mut WriteTxnFunction) -> Result<()> {
-        let mut txn = self.db.begin_write()?;
-        f(&mut txn)?;
+        let txn = self.begin_write()?;
+        let mut table = txn.open_table(TABLE)?;
+        f(&mut table)?;
+        drop(table);
         txn.commit()?;
         Ok(())
     }
     fn read_transaction(&self, f: &mut ReadTxnFunction) -> Result<()> {
-        let mut txn = self.db.begin_read()?;
+        let mut txn = self.begin_read()?;
         f(&mut txn)?;
         Ok(())
     }
 }
-impl WriteTransaction for redb::WriteTransaction {
+
+impl WriteTransaction for Table<'_, &[u8], &[u8]> {
     fn set(&mut self, key: &[u8], value: &[u8]) -> Result<()> {
-        self.open_table(TABLE)?.insert(key, value)?;
+        self.insert(key, value)?;
         Ok(())
     }
     fn del(&mut self, key: &[u8]) -> Result<()> {
-        self.open_table(TABLE)?.remove(key)?;
+        self.remove(key)?;
         Ok(())
     }
 }
-impl ReadTransaction for redb::WriteTransaction {
+impl ReadTransaction for Table<'_, &[u8], &[u8]> {
     fn get<'a>(&'a self, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        match self.open_table(TABLE)?.get(key)? {
+        match <Self as ReadableTable<_, _>>::get(self, key)? {
             Some(v) => Ok(Some(v.value().to_vec())),
             None => Ok(None),
         }
@@ -57,15 +55,14 @@ impl ReadTransaction for redb::WriteTransaction {
         key: &[u8],
         reverse: bool,
     ) -> Result<Box<dyn Iterator<Item = Result<Vec<u8>>> + 'a>> {
-        // let k = |e: Result<(AccessGuard<'_, &[u8]>, AccessGuard<'_, &[u8]>), StorageError>| {
-        //     e.map(|e| e.0.value().to_vec()).map_err(|e| e.into())
-        // };
-        // Ok(if reverse {
-        //     Box::new(self.open_table(TABLE)?.range(..=key)?.rev().map(k))
-        // } else {
-        //     Box::new(self.open_table(TABLE)?.range(key..)?.map(k))
-        // })
-        todo!()
+        let k = |e: Result<(AccessGuard<'_, &[u8]>, AccessGuard<'_, &[u8]>), StorageError>| {
+            e.map(|e| e.0.value().to_vec()).map_err(|e| e.into())
+        };
+        Ok(if reverse {
+            Box::new(self.range(..=key)?.rev().map(k))
+        } else {
+            Box::new(self.range(key..)?.map(k))
+        })
     }
 }
 impl ReadTransaction for redb::ReadTransaction {
diff --git a/database/src/backends/rocksdb.rs b/database/src/backends/rocksdb.rs
index b62a482..1475dac 100644
--- a/database/src/backends/rocksdb.rs
+++ b/database/src/backends/rocksdb.rs
@@ -4,26 +4,19 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use crate::backends::{Db, ReadTransaction, WriteTransaction, WriteTxnFunction};
+use crate::backends::{Database, ReadTransaction, WriteTransaction, WriteTxnFunction};
 use anyhow::Result;
 use rocksdb::{Direction, ErrorKind, IteratorMode, OptimisticTransactionDB};
 use std::path::Path;
 
-pub struct Rocksdb {
-    db: OptimisticTransactionDB,
+pub fn new(path: &Path) -> Result<OptimisticTransactionDB> {
+    Ok(OptimisticTransactionDB::open_default(path)?)
 }
 
-impl Rocksdb {
-    pub fn new(path: &Path) -> Result<Self> {
-        Ok(Self {
-            db: OptimisticTransactionDB::open_default(path)?,
-        })
-    }
-}
-impl Db for Rocksdb {
+impl Database for OptimisticTransactionDB {
     fn write_transaction(&self, f: &mut WriteTxnFunction) -> Result<()> {
         loop {
-            let mut txn = self.db.transaction();
+            let mut txn = self.transaction();
             f(&mut txn)?;
             match txn.commit() {
                 Ok(()) => break Ok(()),
@@ -34,7 +27,7 @@ impl Db for Rocksdb {
     }
     fn read_transaction(&self, f: &mut super::ReadTxnFunction) -> Result<()> {
         loop {
-            let txn = self.db.transaction();
+            let txn = self.transaction();
             f(&txn)?;
             match txn.commit() {
                 Ok(()) => break Ok(()),
diff --git a/database/src/filter/binning.rs b/database/src/filter/binning.rs
index 977d5d7..8588317 100644
--- a/database/src/filter/binning.rs
+++ b/database/src/filter/binning.rs
@@ -4,7 +4,7 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use jellycommon::jellyobject::{Object, path::Path};
+use jellyobject::{Object, Path};
 
 /// Sorted list of components to bin objects by filterable values.
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/database/src/filter/mod.rs b/database/src/filter/mod.rs
index 30a22de..d142c0f 100644
--- a/database/src/filter/mod.rs
+++ b/database/src/filter/mod.rs
@@ -43,7 +43,7 @@ mod test {
         filter::binning::{Binning, BinningComponent},
         query::Filter,
     };
-    use jellycommon::jellyobject::{Tag, path::Path};
+    use jellyobject::{Path, Tag};
 
     #[test]
     fn all() {
diff --git a/database/src/query.rs b/database/src/query.rs
index 7d5c11c..8513e22 100644
--- a/database/src/query.rs
+++ b/database/src/query.rs
@@ -4,7 +4,7 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use jellycommon::jellyobject::path::Path;
+use jellyobject::Path;
 
 pub struct Query {
     pub filter: Filter,
diff --git a/database/src/sort/mod.rs b/database/src/sort/mod.rs
index 6473f5d..9c2eb88 100644
--- a/database/src/sort/mod.rs
+++ b/database/src/sort/mod.rs
@@ -6,7 +6,7 @@
 
 use crate::{backends::WriteTransaction, table::RowNum};
 use anyhow::Result;
-use jellycommon::jellyobject::Object;
+use jellyobject::Object;
 
 pub mod none;
 pub mod value;
diff --git a/database/src/sort/none.rs b/database/src/sort/none.rs
index b17cb29..9285998 100644
--- a/database/src/sort/none.rs
+++ b/database/src/sort/none.rs
@@ -11,7 +11,7 @@ use crate::{
     table::{RowNum, TableNum},
 };
 use anyhow::Result;
-use jellycommon::jellyobject::Object;
+use jellyobject::Object;
 
 pub struct UnsortedIndex {
     id: TableNum,
diff --git a/database/src/table.rs b/database/src/table.rs
index a48dd7e..1680016 100644
--- a/database/src/table.rs
+++ b/database/src/table.rs
@@ -9,7 +9,7 @@ use crate::{
     sort::Index,
 };
 use anyhow::Result;
-use jellycommon::jellyobject::ObjectBuffer;
+use jellyobject::ObjectBuffer;
 
 pub type TableNum = u64;
 pub type RowNum = u64;