1use std::borrow::Borrow;
2
3use redb::{
4 AccessGuard, Key, MultimapRange, MultimapTable, MultimapTableDefinition, MultimapValue, Range,
5 ReadOnlyMultimapTable, ReadOnlyTable, ReadTransaction, ReadableMultimapTable, ReadableTable,
6 Table, TableDefinition, Value, WriteTransaction,
7};
8
9use crate::error::StorageError;
10
11#[derive(Clone, Copy)]
23pub enum Txn<'a> {
24 Write(&'a WriteTransaction),
25 Read(&'a ReadTransaction),
26}
27
28impl<'a> Txn<'a> {
29 pub fn open_table<K: Key + 'static, V: Value + 'static>(
30 &self,
31 def: TableDefinition<K, V>,
32 ) -> Result<TableHandle<'a, K, V>, StorageError> {
33 Ok(match self {
34 Txn::Write(w) => TableHandle::Write(w.open_table(def)?),
35 Txn::Read(r) => TableHandle::Read(r.open_table(def)?),
36 })
37 }
38
39 pub fn open_multimap_table<K: Key + 'static, V: Key + 'static>(
40 &self,
41 def: MultimapTableDefinition<K, V>,
42 ) -> Result<MultimapTableHandle<'a, K, V>, StorageError> {
43 Ok(match self {
44 Txn::Write(w) => MultimapTableHandle::Write(w.open_multimap_table(def)?),
45 Txn::Read(r) => MultimapTableHandle::Read(r.open_multimap_table(def)?),
46 })
47 }
48}
49
50pub enum TableHandle<'a, K: Key + 'static, V: Value + 'static> {
57 Write(Table<'a, K, V>),
58 Read(ReadOnlyTable<K, V>),
59}
60
61impl<'a, K: Key + 'static, V: Value + 'static> TableHandle<'a, K, V> {
62 pub fn get<'k>(
63 &self,
64 key: impl Borrow<K::SelfType<'k>>,
65 ) -> Result<Option<AccessGuard<'_, V>>, StorageError> {
66 Ok(match self {
67 TableHandle::Write(t) => t.get(key)?,
68 TableHandle::Read(t) => t.get(key)?,
69 })
70 }
71
72 pub fn iter(&self) -> Result<Range<'_, K, V>, StorageError> {
73 Ok(match self {
74 TableHandle::Write(t) => t.iter()?,
75 TableHandle::Read(t) => t.iter()?,
76 })
77 }
78}
79
80pub enum MultimapTableHandle<'a, K: Key + 'static, V: Key + 'static> {
81 Write(MultimapTable<'a, K, V>),
82 Read(ReadOnlyMultimapTable<K, V>),
83}
84
85impl<'a, K: Key + 'static, V: Key + 'static> MultimapTableHandle<'a, K, V> {
86 pub fn get<'k>(
87 &self,
88 key: impl Borrow<K::SelfType<'k>>,
89 ) -> Result<MultimapValue<'_, V>, StorageError> {
90 Ok(match self {
91 MultimapTableHandle::Write(t) => t.get(key)?,
92 MultimapTableHandle::Read(t) => t.get(key)?,
93 })
94 }
95
96 #[allow(dead_code)] pub fn iter(&self) -> Result<MultimapRange<'_, K, V>, StorageError> {
98 Ok(match self {
99 MultimapTableHandle::Write(t) => t.iter()?,
100 MultimapTableHandle::Read(t) => t.iter()?,
101 })
102 }
103}