crepedb_redb/
table.rs

1use crepedb_core::{
2    backend::{ReadTable, WriteTable},
3    types::Bytes,
4};
5use redb::{Error, ReadOnlyTable, ReadableTable, Table, TableHandle};
6
7use crate::{types::BytesTy, RedbRange};
8
9/// A read-only table wrapper for redb.
10///
11/// Implements the CrepeDB `ReadTable` trait for redb's `ReadOnlyTable`.
12pub struct RedbReadTable {
13    pub(crate) inner: ReadOnlyTable<BytesTy, BytesTy>,
14    pub(crate) name: String,
15}
16
17impl ReadTable<Error> for RedbReadTable {
18    type Range<'c>
19        = RedbRange<'c>
20    where
21        Self: 'c;
22
23    fn name(&self) -> &str {
24        &self.name
25    }
26
27    fn get(&self, key: Bytes) -> Result<Option<crepedb_core::types::Bytes>, Error> {
28        if let Some(r) = self.inner.get(key)? {
29            Ok(Some(r.value()))
30        } else {
31            Ok(None)
32        }
33    }
34
35    fn range(&self, begin: Bytes, end: Bytes) -> Result<Self::Range<'_>, Error> {
36        let r = self.inner.range(begin..end)?;
37
38        Ok(RedbRange { inner: r })
39    }
40}
41
42/// A writable table wrapper for redb.
43///
44/// Implements both the CrepeDB `ReadTable` and `WriteTable` traits for redb's `Table`.
45pub struct RedbWriteTable<'a> {
46    pub(crate) inner: Table<'a, BytesTy, BytesTy>,
47}
48
49impl<'a> ReadTable<Error> for RedbWriteTable<'a> {
50    type Range<'c>
51        = RedbRange<'c>
52    where
53        Self: 'c;
54
55    fn name(&self) -> &str {
56        self.inner.name()
57    }
58
59    fn get(&self, key: Bytes) -> Result<Option<crepedb_core::types::Bytes>, Error> {
60        if let Some(r) = self.inner.get(key)? {
61            Ok(Some(r.value()))
62        } else {
63            Ok(None)
64        }
65    }
66
67    fn range(&self, begin: Bytes, end: Bytes) -> Result<Self::Range<'_>, Error> {
68        let r = self.inner.range(begin..end)?;
69
70        Ok(RedbRange { inner: r })
71    }
72}
73
74impl<'a> WriteTable<Error> for RedbWriteTable<'a> {
75    fn set(&mut self, key: Bytes, value: Bytes) -> Result<(), Error> {
76        self.inner.insert(key, value)?;
77
78        Ok(())
79    }
80
81    fn del(&mut self, key: Bytes) -> Result<(), Error> {
82        self.inner.remove(key)?;
83
84        Ok(())
85    }
86}