Skip to main content

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}