1use crate::cesr::Matter;
2use crate::cesr::Parsable;
3use crate::keri::db::dbing::LMDBer;
4use crate::keri::db::errors::DBError;
5use crate::keri::db::subing::{SuberBase, SuberError, ValueCodec};
6use std::marker::PhantomData;
7use std::sync::Arc;
8
9pub struct CesrCodec<T: Matter> {
11 _phantom: PhantomData<T>,
12}
13
14impl<T: Matter> ValueCodec for CesrCodec<T> {
15 type Error = SuberError;
16
17 fn serialize<V: ?Sized + Clone + Into<Vec<u8>>>(val: &V) -> Result<Vec<u8>, SuberError> {
18 Ok(val.clone().into())
22 }
23
24 fn deserialize<V: TryFrom<Vec<u8>>>(bytes: &[u8]) -> Result<V, SuberError> {
25 match V::try_from(bytes.to_vec()) {
27 Ok(v) => Ok(v),
28 Err(_) => Err(SuberError::DeserializationError(
29 "Failed to deserialize value".to_string(),
30 )),
31 }
32 }
33}
34
35pub struct CesrSuberBase<M: Matter> {
37 pub base: SuberBase<CesrCodec<M>>,
38 _matter_type: PhantomData<M>,
39}
40
41#[allow(dead_code)]
42impl<M: Matter + Parsable> CesrSuberBase<M> {
43 pub fn new(
44 db: Arc<LMDBer>,
45 subkey: &str,
46 sep: Option<u8>,
47 verify: bool,
48 ) -> Result<Self, SuberError> {
49 let base = SuberBase::<CesrCodec<M>>::new(db, subkey, sep, verify, Some(false))?;
50
51 Ok(Self {
52 base,
53 _matter_type: PhantomData,
54 })
55 }
56
57 pub fn ser(&self, val: &M) -> Result<Vec<u8>, SuberError> {
59 Ok(val.qb64b())
60 }
61
62 pub fn des(&self, val: &[u8]) -> Result<M, SuberError> {
64 Ok(M::from_qb64b(&mut val.to_vec(), None)?)
65 }
66
67 pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
68 self.base.to_key(keys, topive)
69 }
70
71 pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
73 let key = self.base.to_key(keys, false);
74 let val_bytes = self.ser(val)?;
75 Ok(self.base.db.put_val(&self.base.sdb, &key, &val_bytes)?)
76 }
77
78 pub fn put_val(&self, key: &[u8], val: &[u8]) -> Result<bool, DBError> {
79 self.base.db.put_val(&self.base.sdb, key, val)
80 }
81
82 pub fn set_val(&self, key: &[u8], val: &[u8]) -> Result<bool, DBError> {
83 self.base.db.set_val(&self.base.sdb, key, val)
84 }
85
86 pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
88 let key = self.base.to_key(keys, false);
89 let val_bytes = self.ser(val)?;
90 Ok(self.base.db.set_val(&self.base.sdb, &key, &val_bytes)?)
91 }
92
93 pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<M>, SuberError> {
94 let key = self.base.to_key(keys, false);
95 if let Some(val) = self.base.db.get_val(&self.base.sdb, &key)? {
96 Ok(Some(self.des(&val)?))
97 } else {
98 Ok(None)
99 }
100 }
101
102 pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
104 self.base.trim(keys, false)
105 }
106
107 pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
109 Ok(self.base.trim(keys, topive)?)
110 }
111
112 pub fn get_full_item_iter<K: AsRef<[u8]>>(
113 &self,
114 keys: &[K],
115 topive: bool,
116 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
117 Ok(self.base.get_full_item_iter(keys, topive)?)
118 }
119
120 pub fn get_item_iter<K: AsRef<[u8]>>(
121 &self,
122 keys: &[K],
123 topive: bool,
124 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
125 Ok(self.base.get_item_iter(keys, topive)?)
126 }
127
128 pub fn cnt_all(&self) -> Result<usize, SuberError> {
129 Ok(self.base.cnt_all()?)
130 }
131
132 pub fn process_items(
134 &self,
135 items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
136 ) -> Result<Vec<(Vec<Vec<u8>>, M)>, SuberError> {
137 items
138 .into_iter()
139 .map(|(keys, val)| {
140 let matter = self.des(&val)?;
141 Ok((keys, matter))
142 })
143 .collect()
144 }
145}
146
147pub struct CesrSuber<M: Matter> {
149 base: CesrSuberBase<M>,
150}
151
152impl<M: Matter + Parsable> CesrSuber<M> {
153 pub fn new(
154 db: Arc<LMDBer>,
155 subkey: &str,
156 sep: Option<u8>,
157 verify: bool,
158 ) -> Result<Self, SuberError> {
159 let base = CesrSuberBase::new(db, subkey, sep, verify)?;
160
161 Ok(Self { base })
162 }
163
164 pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
166 self.base.pin(keys, val)
167 }
168
169 pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
171 self.base.put(keys, val)
172 }
173
174 pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<M>, SuberError> {
175 self.base.get(keys)
176 }
177
178 pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
179 self.base.rem(keys)
180 }
181
182 pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
183 self.base.trim(keys, topive)
184 }
185
186 pub fn get_full_item_iter<K: AsRef<[u8]>>(
187 &self,
188 keys: &[K],
189 topive: bool,
190 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
191 self.base.get_full_item_iter(keys, topive)
192 }
193
194 pub fn get_item_iter<K: AsRef<[u8]>>(
195 &self,
196 keys: &[K],
197 topive: bool,
198 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
199 self.base.get_item_iter(keys, topive)
200 }
201
202 pub fn process_items(
203 &self,
204 items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
205 ) -> Result<Vec<(Vec<Vec<u8>>, M)>, SuberError> {
206 self.base.process_items(items)
207 }
208
209 pub fn cnt_all(&self) -> Result<usize, SuberError> {
210 self.base.cnt_all()
211 }
212}
213
214#[cfg(test)]
215mod tests {
216 use super::*;
217 use std::sync::Arc;
218
219 use crate::cesr::diger::Diger;
220 use crate::cesr::indexing::siger::Siger;
221 use crate::cesr::{BaseMatter, Matter};
222 use crate::keri::db::dbing::LMDBer;
223 use crate::keri::db::subing::cesr::CesrSuber;
224
225 #[test]
226 fn test_cesr_suber() -> Result<(), SuberError> {
227 let lmdber = LMDBer::builder().name("test_db").temp(true).build()?;
229
230 assert_eq!(lmdber.name(), "test_db");
232 assert!(lmdber.opened());
233
234 let db_ref = Arc::new(lmdber);
235
236 let sdb = CesrSuber::<BaseMatter>::new(db_ref.clone(), "bags.", None, true)?;
238
239 let pre0 = "BDzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc";
241 let val0 = BaseMatter::from_qb64(pre0)?;
242
243 let keys: &[&[u8]] = &[b"alpha".as_ref(), b"dog".as_ref()];
245
246 let result = sdb.put(keys, &val0)?;
248 assert!(result);
249
250 let actual = sdb.get(keys)?.unwrap();
252 assert_eq!(actual.qb64(), val0.qb64());
253
254 let result = sdb.trim(keys, false)?;
256 assert!(result);
257
258 let actual = sdb.get(keys)?;
260 assert!(actual.is_none());
261
262 let result = sdb.put(keys, &val0)?;
264 assert!(result);
265
266 let actual = sdb.get(keys)?.unwrap();
267 assert_eq!(actual.qb64(), val0.qb64());
268
269 let pre1 = "BHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc";
271 let val1 = BaseMatter::from_qb64(pre1)?;
272
273 let result = sdb.put(keys, &val1)?;
275 assert!(!result);
276
277 let actual = sdb.get(keys)?.unwrap();
279 assert_eq!(actual.qb64(), val0.qb64());
280
281 let trim_result = sdb.trim(keys, false)?;
284 assert!(trim_result);
285
286 let put_result = sdb.put(keys, &val1)?;
287 assert!(put_result);
288
289 let actual = sdb.get(keys)?.unwrap();
290 assert_eq!(actual.qb64(), val1.qb64());
291
292 let keys_str: &[&[u8]] = &[b"beta.fish".as_ref()];
294
295 let result = sdb.put(keys_str, &val1)?;
296 assert!(result);
297
298 let actual = sdb.get(keys_str)?.unwrap();
299 assert_eq!(actual.qb64(), val1.qb64());
300
301 let result = sdb.trim(keys_str, false)?;
302 assert!(result);
303
304 let actual = sdb.get(keys_str)?;
305 assert!(actual.is_none());
306
307 let bad_key: &[&[u8]] = &[b"badkey".as_ref()];
309 let actual = sdb.get(bad_key)?;
310 assert!(actual.is_none());
311
312 let sdb_pugs = CesrSuber::<BaseMatter>::new(db_ref.clone(), "pugs.", None, true)?;
314
315 let keys_a1: &[&[u8]] = &[b"a".as_ref(), b"1".as_ref()];
316 let keys_a2: &[&[u8]] = &[b"a".as_ref(), b"2".as_ref()];
317
318 assert!(sdb_pugs.put(keys_a1, &val0)?);
319 assert!(sdb_pugs.put(keys_a2, &val1)?);
320
321 let empty: [&[u8]; 0] = [];
322 let items = sdb_pugs.get_item_iter(&empty, false)?;
323 let processed_items = sdb_pugs.process_items(items)?;
324
325 let mut result_items = Vec::new();
327 for (keys_vec, val) in processed_items {
328 let keys_tuple: Vec<String> = keys_vec
329 .into_iter()
330 .map(|k| String::from_utf8(k).unwrap())
331 .collect();
332
333 result_items.push((keys_tuple, val.qb64()));
334 }
335
336 assert_eq!(result_items.len(), 2);
338 assert_eq!(result_items[0].0, vec!["a".to_string(), "1".to_string()]);
339 assert_eq!(result_items[0].1, val0.qb64());
340 assert_eq!(result_items[1].0, vec!["a".to_string(), "2".to_string()]);
341 assert_eq!(result_items[1].1, val1.qb64());
342
343 let sdb_diger = CesrSuber::<Diger>::new(db_ref.clone(), "pigs.", None, true)?;
345
346 let dig0 = "EAPYGGwTmuupWzwEHHzq7K0gzUhPx5_yZ-Wk1x4ejhcc";
347 let val0 = Diger::from_qb64(dig0)?;
348
349 let keys: &[&[u8]] = &[b"alpha".as_ref(), b"dog".as_ref()];
350
351 assert!(sdb_diger.put(keys, &val0)?);
352
353 let actual = sdb_diger.get(keys)?.unwrap();
354 assert_eq!(actual.qb64(), val0.qb64());
355
356 assert!(sdb_diger.trim(keys, false)?);
357
358 let actual = sdb_diger.get(keys)?;
359 assert!(actual.is_none());
360
361 assert!(sdb_diger.put(keys, &val0)?);
362
363 let actual = sdb_diger.get(keys)?.unwrap();
364 assert_eq!(actual.qb64(), val0.qb64());
365
366 let pre1 = "EHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc";
368 let val1 = BaseMatter::from_qb64(pre1)?;
369
370 let trim_result = sdb_diger.trim(keys, false)?;
376 assert!(trim_result);
377
378 let val1_diger = Diger::from_qb64(pre1)?;
379 let put_result = sdb_diger.put(keys, &val1_diger)?;
380 assert!(put_result);
381
382 let actual = sdb_diger.get(keys)?.unwrap();
383 assert_eq!(actual.qb64(), val1_diger.qb64());
384
385 let sdb_figs = CesrSuber::<Diger>::new(db_ref.clone(), "figs.", None, true)?;
387
388 let keys_a1: &[&[u8]] = &[b"a".as_ref(), b"1".as_ref()];
389 let keys_a2: &[&[u8]] = &[b"a".as_ref(), b"2".as_ref()];
390
391 assert!(sdb_figs.put(keys_a1, &val0)?);
392 assert!(sdb_figs.put(keys_a2, &val1_diger)?);
393
394 let items = sdb_figs.get_item_iter(&empty, false)?;
395 let processed_items = sdb_figs.process_items(items)?;
396
397 let mut result_items = Vec::new();
398 for (keys_vec, val) in processed_items {
399 let keys_tuple: Vec<String> = keys_vec
400 .into_iter()
401 .map(|k| String::from_utf8(k).unwrap())
402 .collect();
403
404 result_items.push((keys_tuple, val.qb64()));
405 }
406
407 assert_eq!(result_items.len(), 2);
408 assert_eq!(result_items[0].0, vec!["a".to_string(), "1".to_string()]);
409 assert_eq!(result_items[0].1, val0.qb64());
410 assert_eq!(result_items[1].0, vec!["a".to_string(), "2".to_string()]);
411 assert_eq!(result_items[1].1, val1_diger.qb64());
412
413 let keys_b1: &[&[u8]] = &[b"b".as_ref(), b"1".as_ref()];
415 let keys_b2: &[&[u8]] = &[b"b".as_ref(), b"2".as_ref()];
416 let keys_bc1: &[&[u8]] = &[b"bc".as_ref(), b"1".as_ref()];
417
418 assert!(sdb_figs.put(keys_b1, &val0)?);
419 assert!(sdb_figs.put(keys_b2, &val1_diger)?);
420 assert!(sdb_figs.put(keys_bc1, &val0)?);
421
422 let top_keys: &[&[u8]] = &[b"b".as_ref(), b"".as_ref()];
424 let items = sdb_figs.get_item_iter(top_keys, true)?;
425 let processed_items = sdb_figs.process_items(items)?;
426
427 let mut result_items = Vec::new();
428 for (keys_vec, val) in processed_items {
429 let keys_tuple: Vec<String> = keys_vec
430 .into_iter()
431 .map(|k| String::from_utf8(k).unwrap())
432 .collect();
433
434 result_items.push((keys_tuple, val.qb64()));
435 }
436
437 assert_eq!(result_items.len(), 2);
438 assert_eq!(result_items[0].0, vec!["b".to_string(), "1".to_string()]);
439 assert_eq!(result_items[0].1, val0.qb64());
440 assert_eq!(result_items[1].0, vec!["b".to_string(), "2".to_string()]);
441 assert_eq!(result_items[1].1, val1_diger.qb64());
442
443 let sdb_siger = CesrSuber::<Siger>::new(db_ref.clone(), "pigs.", None, true).unwrap();
445
446 let sig0 = "AACdI8OSQkMJ9r-xigjEByEjIua7LHH3AOJ22PQKqljMhuhcgh9nGRcKnsz5KvKd7K_H9-1298F4Id1DxvIoEmCQ";
447 let val0 = Siger::from_qb64(sig0, None)?;
448
449 let keys: &[&[u8]] = &[b"zeta".as_ref(), b"cat".as_ref()];
450
451 assert!(sdb_siger.put(keys, &val0)?);
452
453 let actual = sdb_siger.get(keys)?.unwrap();
454 assert_eq!(actual.qb64(), val0.qb64());
455
456 Ok(())
457 }
458}