libkeri/keri/db/subing/mod.rs
1pub mod catcesr;
2pub mod catcesrioset;
3pub mod cesr;
4pub mod cesrioset;
5pub mod dup;
6pub mod iodup;
7pub mod ioset;
8pub mod on;
9pub mod oniodup;
10pub mod serder;
11pub mod signer;
12
13use crate::errors::MatterError;
14use crate::keri::db::dbing::BytesDatabase;
15use crate::keri::db::dbing::LMDBer;
16use crate::keri::db::errors::DBError;
17use std::fmt::Debug;
18use std::marker::PhantomData;
19use std::sync::Arc;
20
21// Error type for database operations
22#[derive(Debug, thiserror::Error)]
23pub enum SuberError {
24 #[error("Database error: {0}")]
25 DBError(#[from] DBError),
26
27 #[error("Key conversion error: {0}")]
28 KeyConversionError(String),
29
30 #[error("Value conversion error: {0}")]
31 ValueConversionError(String),
32
33 #[error("Deserialization error: {0}")]
34 DeserializationError(String),
35
36 #[error("Encryption error: {0}")]
37 EncryptionError(String),
38
39 #[error("Encryption error: {0}")]
40 DecryptionError(String),
41
42 #[error("Verfer error: {0}")]
43 VerferError(String),
44
45 #[error("Matter error: {0}")]
46 MatterError(#[from] MatterError),
47
48 #[error("Empty Keys")]
49 EmptyKeys,
50}
51
52// A trait for serialization/deserialization behavior
53pub trait ValueCodec {
54 // The error type used for serialization/deserialization errors
55 type Error: std::error::Error + 'static;
56
57 // Serialize a value to bytes
58 fn serialize<T: ?Sized + Clone + Into<Vec<u8>>>(val: &T) -> Result<Vec<u8>, SuberError>;
59
60 // Deserialize bytes to a value
61 fn deserialize<T: TryFrom<Vec<u8>>>(bytes: &[u8]) -> Result<T, SuberError>;
62}
63
64// Default implementation for UTF-8 string serialization/deserialization
65pub struct Utf8Codec;
66
67impl From<std::convert::Infallible> for SuberError {
68 fn from(_: std::convert::Infallible) -> Self {
69 // This code will never run because Infallible can't be created
70 unreachable!("This should never happen as Infallible cannot be instantiated")
71 }
72}
73
74impl ValueCodec for Utf8Codec {
75 type Error = SuberError;
76
77 fn serialize<T: ?Sized + Clone + Into<Vec<u8>>>(val: &T) -> Result<Vec<u8>, SuberError> {
78 // Implementation depends on T
79 Ok(val.clone().into())
80 }
81
82 fn deserialize<T: TryFrom<Vec<u8>>>(bytes: &[u8]) -> Result<T, SuberError> {
83 // Convert &[u8] to Vec<u8> first, then use try_from
84 match T::try_from(bytes.to_vec()) {
85 Ok(value) => Ok(value),
86 Err(_) => Err(SuberError::DeserializationError(
87 "Failed to convert bytes to the desired type".to_string(),
88 )),
89 }
90 }
91}
92
93// The base struct for sub-database functionality
94pub struct SuberBase<C: ValueCodec = Utf8Codec> {
95 db: Arc<LMDBer>, // The base LMDB database
96 pub sdb: BytesDatabase, // The sub-database
97 sep: u8, // Separator for combining keys
98 verify: bool, // Whether to verify data when deserializing
99 dupsort: bool, // Whether the database allows duplicates
100 _codec: PhantomData<C>, // Phantom data to track the codec type
101}
102
103impl<C: ValueCodec> SuberBase<C> {
104 pub fn new(
105 db: Arc<LMDBer>,
106 subkey: &str,
107 sep: Option<u8>,
108 verify: bool,
109 dupsort: Option<bool>,
110 ) -> Result<Self, SuberError> {
111 let dupsort = dupsort.unwrap_or(false);
112 let sdb = db.create_database(Some(subkey), Some(dupsort))?;
113
114 Ok(Self {
115 db,
116 sdb,
117 sep: sep.unwrap_or(b'.'),
118 verify,
119 dupsort,
120 _codec: PhantomData,
121 })
122 }
123
124 pub fn is_dupsort(&self) -> bool {
125 self.dupsort
126 }
127
128 // Convert various key forms to bytes
129 pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
130 // Logic to convert keys to a single byte vector with separators
131 // Similar to Python's _tokey method
132 let mut result = Vec::new();
133
134 // If there's only one key and it's already bytes, return it directly
135 if keys.len() == 1 {
136 let key = keys[0].as_ref();
137 if !topive {
138 return key.to_vec();
139 }
140 // For topive=true, append separator
141 result.extend_from_slice(key);
142 result.push(self.sep);
143 return result;
144 }
145
146 // Join multiple keys with separators
147 for (i, key) in keys.iter().enumerate() {
148 if i > 0 {
149 result.push(self.sep);
150 }
151 result.extend_from_slice(key.as_ref());
152 }
153
154 // Add trailing separator for topive
155 if topive && (!result.is_empty() && result[result.len() - 1] != self.sep) {
156 result.push(self.sep);
157 }
158
159 result
160 }
161
162 // Convert a key to a vector of key parts
163 pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
164 // Logic to split key at separators
165 // Similar to Python's _tokeys method
166 key.split(|&b| b == self.sep)
167 .map(|part| part.to_vec())
168 .collect()
169 }
170
171 // Serialize a value to bytes
172 pub fn ser<T: ?Sized + Clone + Into<Vec<u8>>>(&self, val: &T) -> Result<Vec<u8>, SuberError> {
173 C::serialize(val)
174 }
175
176 // Deserialize bytes to a value
177 pub fn des<T: TryFrom<Vec<u8>>>(&self, val: &[u8]) -> Result<T, SuberError> {
178 C::deserialize(val)
179 }
180
181 // Common database operations
182
183 // Remove entries with keys starting with a prefix
184 pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
185 let key = self.to_key(keys, topive);
186 Ok(self.db.del_top_val(&self.sdb, &key)?)
187 }
188
189 // Iterator for full items (with all parts visible)
190 pub fn get_full_item_iter<K: AsRef<[u8]>>(
191 &self,
192 keys: &[K],
193 topive: bool,
194 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
195 let key = self.to_key(keys, topive);
196
197 let mut result = Vec::new();
198 self.db.get_top_items_iter(&self.sdb, &key, |k, v| {
199 result.push((self.to_keys(k), v.to_vec()));
200 Ok(true) // Continue iteration for all items
201 })?;
202
203 Ok(result)
204 }
205
206 // Iterator for normal items (hiding implementation details)
207 pub fn get_item_iter<K: AsRef<[u8]>>(
208 &self,
209 keys: &[K],
210 topive: bool,
211 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
212 // By default, this is the same as get_full_item_iter
213 // Subclasses would override this to hide implementation details
214 self.get_full_item_iter(keys, topive)
215 }
216
217 // Count all items in the database
218 pub fn cnt_all(&self) -> Result<usize, SuberError> {
219 Ok(self.db.cnt(&self.sdb)?)
220 }
221}
222
223// Suber - a subclass of SuberBase that doesn't allow duplicates
224pub struct Suber<C: ValueCodec = Utf8Codec> {
225 pub base: SuberBase<C>,
226}
227
228impl<C: ValueCodec> Suber<C> {
229 pub fn new(
230 db: Arc<LMDBer>,
231 subkey: &str,
232 sep: Option<u8>,
233 verify: bool,
234 ) -> Result<Self, SuberError> {
235 Ok(Self {
236 base: SuberBase::new(db, subkey, sep, verify, Some(false))?,
237 })
238 }
239
240 // Put a value at keys (doesn't overwrite)
241 pub fn put<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
242 &self,
243 keys: &[K],
244 val: &V,
245 ) -> Result<bool, SuberError> {
246 let key = self.base.to_key(keys, false);
247 let val_bytes = self.base.ser(val)?;
248 Ok(self.base.db.put_val(&self.base.sdb, &key, &val_bytes)?)
249 }
250
251 // Pin (set) a value at keys (overwrites)
252 pub fn pin<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
253 &self,
254 keys: &[K],
255 val: &V,
256 ) -> Result<bool, SuberError> {
257 let key = self.base.to_key(keys, false);
258 let val_bytes = self.base.ser(val)?;
259 Ok(self.base.db.set_val(&self.base.sdb, &key, &val_bytes)?)
260 }
261
262 // Get a value at keys
263 pub fn get<K: AsRef<[u8]>, V: TryFrom<Vec<u8>>>(
264 &self,
265 keys: &[K],
266 ) -> Result<Option<V>, SuberError> {
267 let key = self.base.to_key(keys, false);
268 if let Some(val) = self.base.db.get_val(&self.base.sdb, &key)? {
269 Ok(Some(self.base.des(&val)?))
270 } else {
271 Ok(None)
272 }
273 }
274
275 // Remove an entry at keys
276 pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
277 let key = self.base.to_key(keys, false);
278 Ok(self.base.db.del_val(&self.base.sdb, &key)?)
279 }
280
281 // Delegate methods to the base implementation
282 pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
283 self.base.trim(keys, topive)
284 }
285
286 pub fn get_full_item_iter<K: AsRef<[u8]>>(
287 &self,
288 keys: &[K],
289 topive: bool,
290 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
291 self.base.get_full_item_iter(keys, topive)
292 }
293
294 pub fn get_item_iter<K: AsRef<[u8]>>(
295 &self,
296 keys: &[K],
297 topive: bool,
298 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
299 self.base.get_item_iter(keys, topive)
300 }
301
302 pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
303 self.base.to_key(keys, topive)
304 }
305
306 pub fn cnt_all(&self) -> Result<usize, SuberError> {
307 self.base.cnt_all()
308 }
309}
310
311#[cfg(test)]
312mod tests {
313 use super::*;
314 use crate::keri::db::dbing::LMDBer;
315 use crate::keri::db::subing::{Suber, SuberError};
316 use std::sync::Arc;
317
318 #[test]
319 fn test_suber() -> Result<(), SuberError> {
320 // Create a temporary directory for the test
321 let lmdber = LMDBer::builder().name("test_db").temp(true).build()?;
322
323 // Create "seen." database
324 assert_eq!(lmdber.name(), "test_db");
325 assert!(lmdber.opened());
326
327 // Create Suber
328 let lmdber = Arc::new(lmdber);
329 let suber: Suber<Utf8Codec> = Suber::new(lmdber.clone(), "bags.", None, false)?;
330
331 let sue = "Hello sailer!";
332
333 // Test with tuple keys
334 let keys: &[&[u8]] = &["test_key".as_bytes(), "0001".as_bytes()];
335 suber.put(keys, &sue.as_bytes().to_vec())?;
336 let actual = suber.get(keys).expect("Should return a string");
337 assert_eq!(actual, Some(sue.as_bytes().to_vec()));
338
339 suber.rem(keys)?;
340 let actual: Option<Vec<u8>> = suber.get(keys).expect("Should return a string");
341 assert_eq!(actual, None);
342
343 suber.put(keys, &sue.as_bytes().to_vec())?;
344 let actual = suber.get(keys).expect("Should return a string");
345 assert_eq!(actual, Some(sue.as_bytes().to_vec()));
346
347 let kip = "Hey gorgeous!";
348 let result = suber.put(keys, &kip)?;
349 assert!(!result);
350 let actual = suber.get(keys).expect("Should return a string");
351 assert_eq!(actual, Some(sue.as_bytes().to_vec()));
352
353 let result = suber.pin(keys, &kip)?;
354 assert!(result);
355 let actual = suber.get(keys)?;
356 assert_eq!(actual, Some(kip.as_bytes().to_vec()));
357
358 suber.rem(keys)?;
359 let actual: Option<Vec<u8>> = suber.get(keys)?;
360 assert_eq!(actual, None);
361
362 suber.put(keys, &sue)?;
363 let actual = suber.get(keys)?;
364 assert_eq!(actual, Some(sue.as_bytes().to_vec()));
365
366 // Test with keys as tuple of bytes
367 let byte_keys = &[b"test_key".to_vec(), b"0001".to_vec()];
368 suber.rem(byte_keys)?;
369 let actual: Option<Vec<u8>> = suber.get(byte_keys)?;
370 assert_eq!(actual, None);
371
372 suber.put(byte_keys, &sue)?;
373 let actual: Option<Vec<u8>> = suber.get(byte_keys)?;
374 assert_eq!(actual, Some(sue.as_bytes().to_vec()));
375
376 // Test with keys as mixed tuple of bytes and strings
377 let mixed_keys = &[b"test_key".to_vec(), b"0001".to_vec()];
378 suber.rem(mixed_keys)?;
379 let actual: Option<Vec<u8>> = suber.get(mixed_keys)?;
380 assert_eq!(actual, None);
381
382 suber.put(mixed_keys, &sue)?;
383 let actual: Option<Vec<u8>> = suber.get(mixed_keys)?;
384 assert_eq!(actual, Some(sue.as_bytes().to_vec()));
385
386 // Test with keys as string not tuple
387 let key_str = &["keystr"];
388 let bob = "Shove off!";
389
390 suber.put(key_str, &bob)?;
391 let actual: Option<Vec<u8>> = suber.get(key_str)?;
392 assert_eq!(actual, Some(bob.as_bytes().to_vec()));
393
394 suber.rem(key_str)?;
395 let actual: Option<Vec<u8>> = suber.get(key_str)?;
396 assert_eq!(actual, None);
397
398 let liz = "May life is insane.";
399 let liz_keys = &["test_key", "0002"];
400
401 suber.put(liz_keys, &liz)?;
402 let not_found_keys = &["not_found", "0002"];
403 let actual: Option<Vec<u8>> = suber.get(not_found_keys)?;
404 assert_eq!(actual, None);
405
406 let w = "Blue dog";
407 let x = "Green tree";
408 let y = "Red apple";
409 let z = "White snow";
410
411 // // Create a new Suber instance with different subkey
412 let suber: Suber<Utf8Codec> = Suber::new(lmdber.clone(), "pugs.", None, false)?;
413
414 suber.put(&["a", "1"], &w)?;
415 suber.put(&["a", "2"], &x)?;
416 suber.put(&["a", "3"], &y)?;
417 suber.put(&["a", "4"], &z)?;
418
419 // Get all items
420 let ekey: &[u8] = &[];
421 let items = suber.get_item_iter(&[ekey], false)?;
422 let items_vec: Vec<(Vec<Vec<u8>>, String)> = items
423 .into_iter()
424 .map(|(keys, val)| {
425 let string_val = String::from_utf8(val).unwrap();
426 (keys, string_val)
427 })
428 .collect();
429
430 // Convert to a format we can compare with assert_eq
431 let expected = vec![
432 (vec![b"a".to_vec(), b"1".to_vec()], w.to_string()),
433 (vec![b"a".to_vec(), b"2".to_vec()], x.to_string()),
434 (vec![b"a".to_vec(), b"3".to_vec()], y.to_string()),
435 (vec![b"a".to_vec(), b"4".to_vec()], z.to_string()),
436 ];
437
438 assert_eq!(items_vec, expected);
439
440 // suber.put(&["b", "1"], &w)?;
441 // suber.put(&["b", "2"], &x)?;
442 // suber.put(&["bc", "3"], &y)?;
443 // suber.put(&["ac", "4"], &z)?;
444 //
445 // let items = suber.get_item_iter(&[], false)?;
446 // let items_vec: Vec<(Vec<String>, String)> = items
447 // .into_iter()
448 // .map(|(keys, val)| {
449 // let string_keys = keys
450 // .into_iter()
451 // .map(|k| String::from_utf8(k).unwrap())
452 // .collect();
453 // let string_val = String::from_utf8(val).unwrap();
454 // (string_keys, string_val)
455 // })
456 // .collect();
457 //
458 // let expected = vec![
459 // (vec!["a".to_string(), "1".to_string()], "Blue dog".to_string()),
460 // (vec!["a".to_string(), "2".to_string()], "Green tree".to_string()),
461 // (vec!["a".to_string(), "3".to_string()], "Red apple".to_string()),
462 // (vec!["a".to_string(), "4".to_string()], "White snow".to_string()),
463 // (vec!["ac".to_string(), "4".to_string()], "White snow".to_string()),
464 // (vec!["b".to_string(), "1".to_string()], "Blue dog".to_string()),
465 // (vec!["b".to_string(), "2".to_string()], "Green tree".to_string()),
466 // (vec!["bc".to_string(), "3".to_string()], "Red apple".to_string()),
467 // ];
468 //
469 // assert_eq!(items_vec, expected);
470 //
471 // // Test with top keys for partial tree
472 // let topkeys = &["b", ""];
473 // let items = suber.get_item_iter(topkeys, false)?;
474 // let items_vec: Vec<(Vec<String>, String)> = items
475 // .into_iter()
476 // .map(|(keys, val)| {
477 // let string_keys = keys
478 // .into_iter()
479 // .map(|k| String::from_utf8(k).unwrap())
480 // .collect();
481 // let string_val = String::from_utf8(val).unwrap();
482 // (string_keys, string_val)
483 // })
484 // .collect();
485 //
486 // let expected = vec![
487 // (vec!["b".to_string(), "1".to_string()], w.to_string()),
488 // (vec!["b".to_string(), "2".to_string()], x.to_string()),
489 // ];
490 //
491 // assert_eq!(items_vec, expected);
492 //
493 // let topkeys = &["a", ""];
494 // let items = suber.get_item_iter(topkeys, false)?;
495 // let items_vec: Vec<(Vec<String>, String)> = items
496 // .into_iter()
497 // .map(|(keys, val)| {
498 // let string_keys = keys
499 // .into_iter()
500 // .map(|k| String::from_utf8(k).unwrap())
501 // .collect();
502 // let string_val = String::from_utf8(val).unwrap();
503 // (string_keys, string_val)
504 // })
505 // .collect();
506 //
507 // let expected = vec![
508 // (vec!["a".to_string(), "1".to_string()], w.to_string()),
509 // (vec!["a".to_string(), "2".to_string()], x.to_string()),
510 // (vec!["a".to_string(), "3".to_string()], y.to_string()),
511 // (vec!["a".to_string(), "4".to_string()], z.to_string()),
512 // ];
513 //
514 // assert_eq!(items_vec, expected);
515 //
516 // // Test with topive parameter
517 // let keys = &["b"];
518 // let items = suber.get_item_iter(keys, true)?;
519 // let items_vec: Vec<(Vec<String>, String)> = items
520 // .into_iter()
521 // .map(|(keys, val)| {
522 // let string_keys = keys
523 // .into_iter()
524 // .map(|k| String::from_utf8(k).unwrap())
525 // .collect();
526 // let string_val = String::from_utf8(val).unwrap();
527 // (string_keys, string_val)
528 // })
529 // .collect();
530 //
531 // let expected = vec![
532 // (vec!["b".to_string(), "1".to_string()], w.to_string()),
533 // (vec!["b".to_string(), "2".to_string()], x.to_string()),
534 // ];
535 //
536 // assert_eq!(items_vec, expected);
537 //
538 // let keys = &["a"];
539 // let items = suber.get_item_iter(keys, true)?;
540 // let items_vec: Vec<(Vec<String>, String)> = items
541 // .into_iter()
542 // .map(|(keys, val)| {
543 // let string_keys = keys
544 // .into_iter()
545 // .map(|k| String::from_utf8(k).unwrap())
546 // .collect();
547 // let string_val = String::from_utf8(val).unwrap();
548 // (string_keys, string_val)
549 // })
550 // .collect();
551 //
552 // let expected = vec![
553 // (vec!["a".to_string(), "1".to_string()], w.to_string()),
554 // (vec!["a".to_string(), "2".to_string()], x.to_string()),
555 // (vec!["a".to_string(), "3".to_string()], y.to_string()),
556 // (vec!["a".to_string(), "4".to_string()], z.to_string()),
557 // ];
558 //
559 // assert_eq!(items_vec, expected);
560 //
561 // // Test trim
562 // assert!(suber.trim(&["b", ""], false)?);
563 // let items = suber.get_item_iter(&[], false)?;
564 // let items_vec: Vec<(Vec<String>, String)> = items
565 // .into_iter()
566 // .map(|(keys, val)| {
567 // let string_keys = keys
568 // .into_iter()
569 // .map(|k| String::from_utf8(k).unwrap())
570 // .collect();
571 // let string_val = String::from_utf8(val).unwrap();
572 // (string_keys, string_val)
573 // })
574 // .collect();
575 //
576 // let expected = vec![
577 // (vec!["a".to_string(), "1".to_string()], "Blue dog".to_string()),
578 // (vec!["a".to_string(), "2".to_string()], "Green tree".to_string()),
579 // (vec!["a".to_string(), "3".to_string()], "Red apple".to_string()),
580 // (vec!["a".to_string(), "4".to_string()], "White snow".to_string()),
581 // (vec!["ac".to_string(), "4".to_string()], "White snow".to_string()),
582 // (vec!["bc".to_string(), "3".to_string()], "Red apple".to_string()),
583 // ];
584 //
585 // assert_eq!(items_vec, expected);
586 //
587 // assert!(suber.trim(&["a", ""], false)?);
588 // let items = suber.get_item_iter(&[], false)?;
589 // let items_vec: Vec<(Vec<String>, String)> = items
590 // .into_iter()
591 // .map(|(keys, val)| {
592 // let string_keys = keys
593 // .into_iter()
594 // .map(|k| String::from_utf8(k).unwrap())
595 // .collect();
596 // let string_val = String::from_utf8(val).unwrap();
597 // (string_keys, string_val)
598 // })
599 // .collect();
600 //
601 // let expected = vec![
602 // (vec!["ac".to_string(), "4".to_string()], "White snow".to_string()),
603 // (vec!["bc".to_string(), "3".to_string()], "Red apple".to_string()),
604 // ];
605 //
606 // assert_eq!(items_vec, expected);
607 //
608 // // Test trim with top parameters
609 // suber.put(&["a", "1"], &w)?;
610 // suber.put(&["a", "2"], &x)?;
611 // suber.put(&["a", "3"], &y)?;
612 // suber.put(&["a", "4"], &z)?;
613 // suber.put(&["b", "1"], &w)?;
614 // suber.put(&["b", "2"], &x)?;
615 //
616 // assert!(suber.trim(&["b"], true)?);
617 // let items = suber.get_item_iter(&[], false)?;
618 // let items_vec: Vec<(Vec<String>, String)> = items
619 // .into_iter()
620 // .map(|(keys, val)| {
621 // let string_keys = keys
622 // .into_iter()
623 // .map(|k| String::from_utf8(k).unwrap())
624 // .collect();
625 // let string_val = String::from_utf8(val).unwrap();
626 // (string_keys, string_val)
627 // })
628 // .collect();
629 //
630 // let expected = vec![
631 // (vec!["a".to_string(), "1".to_string()], "Blue dog".to_string()),
632 // (vec!["a".to_string(), "2".to_string()], "Green tree".to_string()),
633 // (vec!["a".to_string(), "3".to_string()], "Red apple".to_string()),
634 // (vec!["a".to_string(), "4".to_string()], "White snow".to_string()),
635 // (vec!["ac".to_string(), "4".to_string()], "White snow".to_string()),
636 // (vec!["bc".to_string(), "3".to_string()], "Red apple".to_string()),
637 // ];
638 //
639 // assert_eq!(items_vec, expected);
640 //
641 // assert!(suber.trim(&["a"], true)?);
642 // let items = suber.get_item_iter(&[], false)?;
643 // let items_vec: Vec<(Vec<String>, String)> = items
644 // .into_iter()
645 // .map(|(keys, val)| {
646 // let string_keys = keys
647 // .into_iter()
648 // .map(|k| String::from_utf8(k).unwrap())
649 // .collect();
650 // let string_val = String::from_utf8(val).unwrap();
651 // (string_keys, string_val)
652 // })
653 // .collect();
654 //
655 // let expected = vec![
656 // (vec!["ac".to_string(), "4".to_string()], "White snow".to_string()),
657 // (vec!["bc".to_string(), "3".to_string()], "Red apple".to_string()),
658 // ];
659 //
660 // assert_eq!(items_vec, expected);
661 //
662 // assert!(suber.trim(&[], false)?);
663 // let items = suber.get_item_iter(&[], false)?;
664 // let items_vec: Vec<(Vec<String>, String)> = items
665 // .into_iter()
666 // .map(|(keys, val)| {
667 // let string_keys = keys
668 // .into_iter()
669 // .map(|k| String::from_utf8(k).unwrap())
670 // .collect();
671 // let string_val = String::from_utf8(val).unwrap();
672 // (string_keys, string_val)
673 // })
674 // .collect();
675 //
676 // assert_eq!(items_vec, vec![]);
677 //
678 // assert!(!suber.trim(&[], false)?);
679 //
680 // // Close database
681 // drop(lmdber);
682 //
683 Ok(())
684 }
685}