Skip to main content

libkeri/keri/db/subing/
oniodup.rs

1use crate::keri::db::dbing::LMDBer;
2use crate::keri::db::errors::DBError;
3use crate::keri::db::subing::iodup::IoDupSuber;
4use crate::keri::db::subing::on::OnSuberBase;
5use crate::keri::db::subing::{SuberError, Utf8Codec, ValueCodec};
6use std::sync::Arc;
7
8use std::ops::Bound;
9
10pub struct OnIoDupSuber<C: ValueCodec = Utf8Codec> {
11    pub on_base: OnSuberBase<C>,
12    pub io_dup_suber: IoDupSuber<C>,
13}
14
15impl<C: ValueCodec> OnIoDupSuber<C> {
16    pub fn new(
17        db: Arc<LMDBer>,
18        subkey: &str,
19        sep: Option<u8>,
20        verify: bool,
21    ) -> Result<Self, SuberError> {
22        let on_base = OnSuberBase::new(db.clone(), subkey, sep, verify, Some(true))?;
23        let io_dup_suber = IoDupSuber::new(db, subkey, sep, verify)?;
24
25        Ok(Self {
26            on_base,
27            io_dup_suber,
28        })
29    }
30
31    /// Adds val idempotently at key made from keys in insertion order using hidden ordinal proem.
32    /// Idempotently means do not add val that is already in dup vals at key. Does not overwrite.
33    pub fn add_on<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
34        &self,
35        keys: &[K],
36        on: u32,
37        val: &V,
38    ) -> Result<bool, SuberError> {
39        let key = self.on_base._tokey(keys);
40        let sval = self.on_base._ser(val)?;
41
42        self.on_base
43            .base
44            .db
45            .add_on_io_dup_val(
46                &self.on_base.base.sdb,
47                &key,
48                Some(on as u64),
49                &sval,
50                Some([self.on_base.base.sep]),
51            )
52            .map_err(SuberError::DBError)
53    }
54
55    /// Appends a value and returns the ordinal number of the newly appended val
56    pub fn append_on<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
57        &self,
58        keys: &[K],
59        val: &V,
60    ) -> Result<u64, SuberError> {
61        let key = self.on_base._tokey(keys);
62        let sval = self.on_base._ser(val)?;
63
64        self.on_base
65            .base
66            .db
67            .append_on_io_dup_val(
68                &self.on_base.base.sdb,
69                &key,
70                &sval,
71                Some([self.on_base.base.sep]),
72            )
73            .map_err(SuberError::DBError)
74    }
75
76    /// Gets dup vals list at key made from keys
77    pub fn get_on<K: AsRef<[u8]>, R: TryFrom<Vec<u8>>>(
78        &self,
79        keys: &[K],
80        on: u32,
81    ) -> Result<Vec<R>, SuberError>
82    where
83        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
84    {
85        let key = self.on_base._tokey(keys);
86        let mut results = Vec::new();
87
88        self.on_base
89            .base
90            .db
91            .get_on_io_dup_val_iter(
92                &self.on_base.base.sdb,
93                Some(&key),
94                Some(on as u64),
95                Some([self.on_base.base.sep]),
96                |val| {
97                    // Handle the deserialization manually, convert errors if needed
98                    match self.on_base._des(&val) {
99                        Ok(deserialized) => {
100                            results.push(deserialized);
101                            Ok(true) // Continue iteration
102                        }
103                        Err(e) => {
104                            // Convert SuberError to DBError
105                            Err(DBError::ValueError(format!(
106                                "Deserialization error: {:?}",
107                                e
108                            )))
109                        }
110                    }
111                },
112            )
113            .map_err(SuberError::DBError)?;
114
115        Ok(results)
116    }
117
118    /// Removes entry at key made from keys and dup val that matches val if any,
119    /// notwithstanding hidden ordinal proem. Otherwise deletes all dup values
120    /// at key if any.
121    pub fn rem_on<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
122        &self,
123        keys: &[K],
124        on: u32,
125        val: Option<&V>,
126    ) -> Result<bool, SuberError> {
127        let key = self.on_base._tokey(keys);
128
129        match val {
130            Some(v) => {
131                let sval = self.on_base._ser(v)?;
132                self.on_base
133                    .base
134                    .db
135                    .del_on_io_dup_val(
136                        &self.on_base.base.sdb,
137                        &key,
138                        Some(on as u64),
139                        &sval,
140                        Some([self.on_base.base.sep]),
141                    )
142                    .map_err(SuberError::DBError)
143            }
144            None => self
145                .on_base
146                .base
147                .db
148                .del_on_io_dup_vals(
149                    &self.on_base.base.sdb,
150                    &key,
151                    Some(on as u64),
152                    Some([self.on_base.base.sep]),
153                )
154                .map_err(SuberError::DBError),
155        }
156    }
157
158    /// Returns an iterator that yields deserialized values from the database
159    pub fn get_on_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
160        &self,
161        keys: &[K],
162        on: u32,
163    ) -> Result<Box<dyn Iterator<Item = Result<R, SuberError>> + '_>, SuberError>
164    where
165        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
166        SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
167    {
168        let key = self.on_base._tokey(keys);
169        let sep = self.on_base.base.sep;
170
171        // Create a collector that will hold deserialized values
172        let mut collector = Vec::new();
173
174        // Collect the values
175        self.on_base
176            .base
177            .db
178            .get_on_io_dup_val_iter(
179                &self.on_base.base.sdb,
180                Some(&key),
181                Some(on as u64),
182                Some([sep]),
183                |val| {
184                    collector.push(val);
185                    Ok(true)
186                },
187            )
188            .map_err(SuberError::DBError)?;
189
190        // Create an iterator from the collected values
191        let iter = collector.into_iter().map(move |val| {
192            let deserialized: R = self.on_base._des(&val)?;
193            Ok(deserialized)
194        });
195
196        Ok(Box::new(iter))
197    }
198
199    /// Returns an iterator that yields triples of (keys, on, val)
200    pub fn get_on_item_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
201        &self,
202        keys: &[K],
203        on: u32,
204    ) -> Result<Box<dyn Iterator<Item = Result<(Vec<Vec<u8>>, u64, R), SuberError>> + '_>, SuberError>
205    where
206        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
207        SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
208    {
209        let key = self.on_base._tokey(keys);
210        let sep = self.on_base.base.sep;
211
212        // Create a collector that will hold raw items
213        let mut collector = Vec::new();
214
215        // Collect the items
216        self.on_base
217            .base
218            .db
219            .get_on_io_dup_item_iter(
220                &self.on_base.base.sdb,
221                Some(&key),
222                Some(on as u64),
223                Some([sep]),
224                |k, o, v| {
225                    collector.push((k.to_vec(), o, v.to_vec()));
226                    Ok(true)
227                },
228            )
229            .map_err(SuberError::DBError)?;
230
231        // Create an iterator from the collected items
232        let iter = collector.into_iter().map(move |(k, o, v)| {
233            let keys = self.on_base._tokeys(&k);
234            let deserialized: R = self.on_base._des(&v)?;
235            Ok((keys, o, deserialized))
236        });
237
238        Ok(Box::new(iter))
239    }
240
241    /// Returns an iterator that yields the last duplicate value for each key
242    pub fn get_on_last_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
243        &self,
244        keys: &[K],
245        on: u32,
246    ) -> Result<Box<dyn Iterator<Item = Result<R, SuberError>> + '_>, SuberError>
247    where
248        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
249        SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
250    {
251        let key = self.on_base._tokey(keys);
252        let sep = self.on_base.base.sep;
253
254        // Create a collector that will hold values
255        let mut collector = Vec::new();
256
257        // Collect the values
258        self.on_base
259            .base
260            .db
261            .get_on_io_dup_last_val_iter(
262                &self.on_base.base.sdb,
263                Some(&key),
264                Some(on as u64),
265                Some([sep]),
266                |val| {
267                    collector.push(val.to_vec());
268                    Ok(true)
269                },
270            )
271            .map_err(SuberError::DBError)?;
272
273        // Create an iterator from the collected values
274        let iter = collector
275            .into_iter()
276            .map(move |val| self.on_base._des(&val));
277
278        Ok(Box::new(iter))
279    }
280
281    /// Returns an iterator that yields triples of (keys, on, val) for the last duplicate values
282    pub fn get_on_last_item_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
283        &self,
284        keys: &[K],
285        on: u32,
286    ) -> Result<Box<dyn Iterator<Item = Result<(Vec<Vec<u8>>, u64, R), SuberError>> + '_>, SuberError>
287    where
288        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
289        SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
290    {
291        let key = self.on_base._tokey(keys);
292        let sep = self.on_base.base.sep;
293
294        // Create a collector that will hold raw items
295        let mut collector = Vec::new();
296
297        // Collect the items
298        self.on_base
299            .base
300            .db
301            .get_on_io_dup_last_item_iter(
302                &self.on_base.base.sdb,
303                Some(&key),
304                Some(on as u64),
305                Some([sep]),
306                |k, o, v| {
307                    collector.push((k.to_vec(), o, v.to_vec()));
308                    Ok(true)
309                },
310            )
311            .map_err(SuberError::DBError)?;
312
313        // Create an iterator from the collected items
314        let iter = collector.into_iter().map(move |(k, o, v)| {
315            let keys = self.on_base._tokeys(&k);
316            let deserialized: R = self.on_base._des(&v)?;
317            Ok((keys, o, deserialized))
318        });
319
320        Ok(Box::new(iter))
321    }
322
323    /// Returns an iterator that yields deserialized values from the database in reverse order
324    pub fn get_on_back_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
325        &self,
326        keys: &[K],
327        on: u32,
328    ) -> Result<Box<dyn Iterator<Item = Result<R, SuberError>> + '_>, SuberError>
329    where
330        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
331        SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
332    {
333        let key = self.on_base._tokey(keys);
334        let sep = self.on_base.base.sep;
335
336        // Create a collector that will hold values
337        let mut collector = Vec::new();
338
339        // Collect the values
340        self.on_base
341            .base
342            .db
343            .get_on_io_dup_val_back_iter(
344                &self.on_base.base.sdb,
345                Some(&key),
346                Some(on as u64),
347                Some([sep]),
348                |val| {
349                    collector.push(val.to_vec());
350                    Ok(true)
351                },
352            )
353            .map_err(SuberError::DBError)?;
354
355        // Create an iterator from the collected values
356        let iter = collector
357            .into_iter()
358            .map(move |val| self.on_base._des(&val));
359
360        Ok(Box::new(iter))
361    }
362
363    /// Returns an iterator that yields triples of (keys, on, val) in reverse order
364    pub fn get_on_item_back_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
365        &self,
366        keys: &[K],
367        on: u32,
368    ) -> Result<Box<dyn Iterator<Item = Result<(Vec<Vec<u8>>, u64, R), SuberError>> + '_>, SuberError>
369    where
370        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
371        SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
372    {
373        let key = self.on_base._tokey(keys);
374        let sep = self.on_base.base.sep;
375
376        // Create a collector that will hold raw items
377        let mut collector = Vec::new();
378
379        // Collect the items
380        self.on_base
381            .base
382            .db
383            .get_on_io_dup_item_back_iter(
384                &self.on_base.base.sdb,
385                Some(&key),
386                Some(on as u64),
387                Some([sep]),
388                |k, o, v| {
389                    collector.push((k.to_vec(), o, v.to_vec()));
390                    Ok(true)
391                },
392            )
393            .map_err(SuberError::DBError)?;
394
395        // Create an iterator from the collected items
396        let iter = collector.into_iter().map(move |(k, o, v)| {
397            let keys = self.on_base._tokeys(&k);
398            let deserialized: R = self.on_base._des(&v)?;
399            Ok((keys, o, deserialized))
400        });
401
402        Ok(Box::new(iter))
403    }
404
405    /// Counts the number of values with ordinal number suffix
406    ///
407    /// # Returns
408    /// * Count of all ordinal suffix keyed vals with same key prefix but different on in onkey
409    ///
410    /// # Parameters
411    /// * `keys` - Top keys as prefix to be combined with serialized on suffix and sep to form top key
412    /// * `on` - Ordinal number used to form key
413    pub fn cnt_on<K: AsRef<[u8]>>(&self, keys: &[K], on: u32) -> Result<usize, SuberError> {
414        self.on_base.cnt_on(keys, on)
415    }
416
417    /// Returns an iterator over all the items (keys, value) whose effective key starts with
418    /// the prefix derived from keys.
419    ///
420    /// # Arguments
421    /// * `keys` - Slice of key parts, potentially a partial key
422    /// * `topive` - If true, treat as partial key tuple ending with separator
423    ///
424    /// # Returns
425    /// * `Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError>` - Vector of key-value pairs
426    pub fn get_item_iter<K: AsRef<[u8]>>(
427        &self,
428        keys: &[K],
429        topive: bool,
430    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
431        self.io_dup_suber.get_item_iter(keys, topive)
432    }
433
434    /// Add val idempotently at key made from keys in insertion order using hidden
435    /// ordinal proem. Idempotently means do not add val that is already in
436    /// dup vals at key. Does not overwrite.
437    ///
438    /// # Arguments
439    /// * `keys` - Slice of key parts to be combined to form the key
440    /// * `val` - Value to be stored
441    ///
442    /// # Returns
443    /// * `Result<bool, SuberError>` - True means unique value added among duplications,
444    ///   False means duplicate of same value already exists.
445    pub fn add<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
446        &self,
447        keys: &[K],
448        val: &V,
449    ) -> Result<bool, SuberError> {
450        self.io_dup_suber.add(keys, val)
451    }
452
453    /// Gets the last value inserted at the given keys.
454    ///
455    /// # Arguments
456    ///
457    /// * `keys`: An array slice of key parts.
458    ///
459    /// # Returns
460    ///
461    /// `Ok(Some(R))` containing the deserialized last value if found.
462    /// `Ok(None)` if the key does not exist or has no values.
463    /// `Err(SuberError)` on key processing or database/deserialization errors.
464    pub fn get_last<K: AsRef<[u8]>, R: TryFrom<Vec<u8>>>(
465        &self,
466        keys: &[K],
467    ) -> Result<Option<R>, SuberError>
468    where
469        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
470    {
471        self.io_dup_suber.get_last(keys)
472    }
473
474    pub fn get_io_dup_val_last<K: AsRef<[u8]>, R: TryFrom<Vec<u8>>>(
475        &self,
476        keys: &[K],
477    ) -> Result<Option<R>, SuberError>
478    where
479        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
480    {
481        // Convert the key components to a single key
482        let key = self.on_base._tokey(keys);
483
484        // Call the underlying get_io_dup_val_last method from LMDBer
485        match self
486            .on_base
487            .base
488            .db
489            .get_io_dup_val_last(&self.on_base.base.sdb, &key)
490        {
491            Ok(Some(val_bytes)) => {
492                // Deserialize the value using the codec
493                match self.on_base._des(&val_bytes) {
494                    Ok(deserialized) => Ok(Some(deserialized)),
495                    Err(e) => Err(e),
496                }
497            }
498            Ok(None) => Ok(None),
499            Err(e) => Err(SuberError::DBError(e)),
500        }
501    }
502
503    pub fn get<K: AsRef<[u8]>, R: TryFrom<Vec<u8>>>(&self, keys: &[K]) -> Result<Vec<R>, SuberError>
504    where
505        <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
506    {
507        self.io_dup_suber.get(keys)
508    }
509
510    pub fn is_dupsort(&self) -> bool {
511        self.on_base.base.is_dupsort()
512    }
513}
514#[cfg(test)]
515mod tests {
516    use crate::keri::db::dbing::keys::on_key;
517    use crate::keri::db::dbing::{LMDBer, LMDBerBuilder};
518    use crate::keri::db::subing::oniodup::OnIoDupSuber;
519    use crate::keri::db::subing::{SuberError, Utf8Codec};
520    use std::sync::Arc;
521    use tempfile::tempdir;
522
523    #[test]
524    fn test_on_iodup_suber() -> Result<(), SuberError> {
525        // Create a tempdir to ensure test isolation
526        let temp_dir = tempdir().unwrap();
527        let _dir_path = temp_dir.path().to_path_buf();
528
529        // Open a test database
530        let db = LMDBerBuilder::default()
531            .name("test")
532            .temp(true)
533            .build()
534            .unwrap();
535
536        assert_eq!(db.name(), "test");
537        assert!(db.opened());
538
539        // Create OnIoDupSuber
540        let db_ref = Arc::new(db);
541        let onsuber = OnIoDupSuber::<Utf8Codec>::new(db_ref, "bags.", None, false)?;
542        assert!(onsuber.is_dupsort());
543
544        let w = "Blue dog";
545        let x = "Green tree";
546        let y = "Red apple";
547        let z = "White snow";
548
549        // Test addOn, remOn
550        assert!(onsuber.add_on(&["z"], 0, &w)?);
551        let bytes: Vec<Vec<u8>> = onsuber.get_on(&["z"], 0)?;
552        let vals: Vec<String> = bytes
553            .iter()
554            .map(|b| String::from_utf8(b.clone()).unwrap())
555            .collect();
556        assert_eq!(vals, vec![w.to_string()]);
557
558        assert!(onsuber.add_on(&["z"], 0, &x)?);
559        let bytes: Vec<Vec<u8>> = onsuber.get_on(&["z"], 0)?;
560        let vals: Vec<String> = bytes
561            .iter()
562            .map(|b| String::from_utf8(b.clone()).unwrap())
563            .collect();
564        assert_eq!(vals, vec![w.to_string(), x.to_string()]);
565
566        assert!(onsuber.add_on(&["z"], 1, &y)?);
567        let bytes: Vec<Vec<u8>> = onsuber.get_on(&["z"], 1)?;
568        let vals: Vec<String> = bytes
569            .iter()
570            .map(|b| String::from_utf8(b.clone()).unwrap())
571            .collect();
572        assert_eq!(vals, vec![y.to_string()]);
573
574        assert!(onsuber.add_on(&["z"], 1, &z)?);
575        let bytes: Vec<Vec<u8>> = onsuber.get_on(&["z"], 1)?;
576        let vals: Vec<String> = bytes
577            .iter()
578            .map(|b| String::from_utf8(b.clone()).unwrap())
579            .collect();
580        assert_eq!(vals, vec![y.to_string(), z.to_string()]);
581
582        assert_eq!(onsuber.cnt_on(&["z"], 0)?, 4);
583
584        // Test getOnItemIter - collect items similar to Python test
585        let mut items = Vec::new();
586        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["z"], 0)?; // Use Vec<u8> here
587        for item_result in item_iter {
588            let (keys, on, val) = item_result?;
589            let keys_vec = keys
590                .iter()
591                .map(|k| String::from_utf8(k.clone()).unwrap())
592                .collect::<Vec<_>>();
593            // Convert the Vec<u8> to String
594            let val_string = String::from_utf8(val).unwrap();
595            items.push((keys_vec, on, val_string));
596        }
597        assert_eq!(
598            items,
599            vec![
600                (vec!["z".to_string()], 0, "Blue dog".to_string()),
601                (vec!["z".to_string()], 0, "Green tree".to_string()),
602                (vec!["z".to_string()], 1, "Red apple".to_string()),
603                (vec!["z".to_string()], 1, "White snow".to_string())
604            ]
605        );
606
607        // Test removal
608        assert!(onsuber.rem_on(&["z"], 0, Some(&w))?);
609        assert!(onsuber.rem_on(&["z"], 1, None::<&String>)?);
610
611        // Check remaining items after removal
612        let mut items = Vec::new();
613        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["z"], 0)?;
614        for item_result in item_iter {
615            let (keys, on, val) = item_result?;
616            let keys_vec = keys
617                .iter()
618                .map(|k| String::from_utf8(k.clone()).unwrap())
619                .collect::<Vec<_>>();
620            // Convert the Vec<u8> to String
621            let val_string = String::from_utf8(val).unwrap();
622            items.push((keys_vec, on, val_string));
623        }
624        assert_eq!(
625            items,
626            vec![(vec!["z".to_string()], 0, "Green tree".to_string())]
627        );
628
629        assert!(onsuber.rem_on(&["z"], 0, Some(&x))?);
630        assert_eq!(onsuber.cnt_on(&["z"], 0)?, 0);
631
632        // Test appendOn
633        assert_eq!(onsuber.append_on(&["a"], &w)?, 0);
634        assert_eq!(onsuber.append_on(&["a"], &x)?, 1);
635        assert_eq!(onsuber.append_on(&["a"], &y)?, 2);
636        assert_eq!(onsuber.append_on(&["a"], &z)?, 3);
637
638        assert_eq!(onsuber.cnt_on(&["a"], 2)?, 2);
639        assert_eq!(onsuber.cnt_on(&["a"], 4)?, 0);
640        assert_eq!(onsuber.cnt_on(&["a"], 0)?, 4);
641
642        // Test getItemIter
643        let raw_items = onsuber.get_item_iter(
644            &["a"] as &[&str],
645            false, // Use a simple key prefix instead of on_key
646        )?;
647
648        let items_strings = raw_items
649            .iter()
650            .map(|(keys, val)| {
651                let key_strings = keys
652                    .iter()
653                    .map(|k| String::from_utf8(k.clone()).unwrap())
654                    .collect::<Vec<_>>();
655                (key_strings, String::from_utf8(val.clone()).unwrap())
656            })
657            .collect::<Vec<_>>();
658
659        // Check the structure of the items
660        assert_eq!(items_strings.len(), 4);
661        assert_eq!(items_strings[0].1, "Blue dog");
662        assert_eq!(items_strings[1].1, "Green tree");
663        assert_eq!(items_strings[2].1, "Red apple");
664        assert_eq!(items_strings[3].1, "White snow");
665
666        // Test getOnIter
667        let mut vals = Vec::new();
668        let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["a"], 0)?;
669
670        for val_result in val_iter {
671            let raw_bytes = val_result?;
672            let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
673            vals.push(string_val);
674        }
675
676        assert_eq!(
677            vals,
678            vec![
679                "Blue dog".to_string(),
680                "Green tree".to_string(),
681                "Red apple".to_string(),
682                "White snow".to_string()
683            ]
684        );
685
686        // Test getOnIter with on=2
687        let mut vals = Vec::new();
688        let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["a"], 2)?;
689        for val_result in val_iter {
690            let raw_bytes = val_result?;
691            let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
692            vals.push(string_val);
693        }
694        assert_eq!(
695            vals,
696            vec!["Red apple".to_string(), "White snow".to_string()]
697        );
698
699        // Test getOnItemIter
700        let mut items = Vec::new();
701        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 0)?;
702
703        for item_result in item_iter {
704            let (keys, on, raw_bytes) = item_result?;
705            let keys_vec = keys
706                .iter()
707                .map(|k| String::from_utf8(k.clone()).unwrap())
708                .collect::<Vec<_>>();
709            let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
710            items.push((keys_vec, on, val));
711        }
712
713        assert_eq!(
714            items,
715            vec![
716                (vec!["a".to_string()], 0, "Blue dog".to_string()),
717                (vec!["a".to_string()], 1, "Green tree".to_string()),
718                (vec!["a".to_string()], 2, "Red apple".to_string()),
719                (vec!["a".to_string()], 3, "White snow".to_string())
720            ]
721        );
722
723        // Test getOnItemIter with on=2
724        let mut items = Vec::new();
725        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 2)?;
726        for item_result in item_iter {
727            let (keys, on, raw_bytes) = item_result?;
728            let keys_vec = keys
729                .iter()
730                .map(|k| String::from_utf8(k.clone()).unwrap())
731                .collect::<Vec<_>>();
732            let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
733            items.push((keys_vec, on, val));
734        }
735        assert_eq!(
736            items,
737            vec![
738                (vec!["a".to_string()], 2, "Red apple".to_string()),
739                (vec!["a".to_string()], 3, "White snow".to_string())
740            ]
741        );
742
743        // Test add with duplicates using direct add method
744        assert!(onsuber.add(&[on_key("b".as_bytes(), 0, None)], &w)?);
745        assert!(onsuber.add(&[on_key("b".as_bytes(), 1, None)], &x)?);
746        assert!(onsuber.add(&[on_key("bc".as_bytes(), 0, None)], &y)?);
747        assert!(onsuber.add(&[on_key("ac".as_bytes(), 0, None)], &z)?);
748
749        assert_eq!(onsuber.cnt_on(&["b"], 0)?, 2);
750        assert_eq!(onsuber.cnt_on(&["ac"], 2)?, 0);
751        assert_eq!(onsuber.cnt_on(&[""], 0)?, 8);
752
753        // Test getItemIter for all items
754        let mut items = Vec::new();
755        for item_result in onsuber.get_item_iter::<Vec<u8>>(&[] as &[Vec<u8>], false)? {
756            // Manually convert Vec<u8> to String
757            let (keys, raw_bytes) = item_result;
758            let keys_vec = keys
759                .iter()
760                .map(|k| String::from_utf8(k.clone()).unwrap())
761                .collect::<Vec<_>>();
762            let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
763            items.push((keys_vec, val));
764        }
765        // Check we have correct number of items
766        assert_eq!(items.len(), 8);
767
768        // Test getOnItemIter for 'b'
769        let mut items = Vec::new();
770        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["b"], 0)?;
771        for item_result in item_iter {
772            let (keys, on, raw_bytes) = item_result?;
773            let keys_vec = keys
774                .iter()
775                .map(|k| String::from_utf8(k.clone()).unwrap())
776                .collect::<Vec<_>>();
777            let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
778            items.push((keys_vec, on, val));
779        }
780        assert_eq!(
781            items,
782            vec![
783                (vec!["b".to_string()], 0, "Blue dog".to_string()),
784                (vec!["b".to_string()], 1, "Green tree".to_string())
785            ]
786        );
787
788        // Test getOnIter for 'b'
789        let mut vals = Vec::new();
790        let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["b"], 0)?;
791        for val_result in val_iter {
792            let raw_bytes = val_result?;
793            let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
794            vals.push(string_val);
795        }
796        assert_eq!(vals, vec!["Blue dog".to_string(), "Green tree".to_string()]);
797
798        // Test getOnIter with tuple key
799        let mut vals = Vec::new();
800        let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["b"], 0)?;
801        for val_result in val_iter {
802            let raw_bytes = val_result?;
803            let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
804            vals.push(string_val);
805        }
806        assert_eq!(vals, vec!["Blue dog".to_string(), "Green tree".to_string()]);
807
808        // Test getOnItemIter with tuple key
809        let mut items = Vec::new();
810        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["b"], 0)?;
811        for item_result in item_iter {
812            let (keys, on, raw_bytes) = item_result?;
813            let keys_vec = keys
814                .iter()
815                .map(|k| String::from_utf8(k.clone()).unwrap())
816                .collect::<Vec<_>>();
817            let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
818            items.push((keys_vec, on, val));
819        }
820        assert_eq!(
821            items,
822            vec![
823                (vec!["b".to_string()], 0, "Blue dog".to_string()),
824                (vec!["b".to_string()], 1, "Green tree".to_string())
825            ]
826        );
827
828        // Test getOnItemIter with invalid key
829        let mut items = Vec::new();
830        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["b", ""], 0)?;
831        for item_result in item_iter {
832            let (keys, on, raw_bytes) = item_result?;
833            let keys_vec = keys
834                .iter()
835                .map(|k| String::from_utf8(k.clone()).unwrap())
836                .collect::<Vec<_>>();
837            let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
838            items.push((keys_vec, on, val));
839        }
840        assert!(items.is_empty());
841
842        // Test getOnIter with invalid key
843        let mut vals = Vec::new();
844        let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["b", ""], 0)?;
845        for val_result in val_iter {
846            vals.push(val_result?);
847        }
848        assert!(vals.is_empty());
849
850        // Test getOnItemIter with empty key (all items)
851        let mut items = Vec::new();
852        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&[""], 0)?;
853        for item_result in item_iter {
854            let (keys, on, val) = item_result?;
855            let keys_vec = keys
856                .iter()
857                .map(|k| String::from_utf8(k.clone()).unwrap())
858                .collect::<Vec<_>>();
859            items.push((keys_vec, on, val));
860        }
861        assert_eq!(items.len(), 8);
862
863        // Test getOnIter with empty key (all items)
864        let mut vals = Vec::new();
865        let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&[""], 0)?;
866        for val_result in val_iter {
867            vals.push(val_result?);
868        }
869        assert_eq!(vals.len(), 8);
870
871        // Test getOnItemIter with no key (all items)
872        let mut items = Vec::new();
873        let item_iter = onsuber.get_on_item_iter::<&str, Vec<u8>>(&[], 0)?;
874        for item_result in item_iter {
875            let (keys, on, val) = item_result?;
876            let keys_vec = keys
877                .iter()
878                .map(|k| String::from_utf8(k.clone()).unwrap())
879                .collect::<Vec<_>>();
880            items.push((keys_vec, on, val));
881        }
882        assert_eq!(items.len(), 8);
883
884        // Test getOnIter with no key (all items)
885        let mut vals = Vec::new();
886        let val_iter = onsuber.get_on_iter::<&str, Vec<u8>>(&[], 0)?;
887        for val_result in val_iter {
888            vals.push(val_result?);
889        }
890        assert_eq!(vals.len(), 8);
891
892        // Test with duplicates
893        assert!(onsuber.add(&[on_key("a".as_bytes(), 0, None)], &z)?);
894        assert!(onsuber.add(&[on_key("a".as_bytes(), 1, None)], &y)?);
895        assert!(onsuber.add(&[on_key("a".as_bytes(), 2, None)], &x)?);
896        assert!(onsuber.add(&[on_key("a".as_bytes(), 3, None)], &w)?);
897
898        assert_eq!(onsuber.cnt_on(&["a"], 0)?, 8);
899        assert_eq!(onsuber.cnt_on(&["a"], 2)?, 4);
900        assert_eq!(onsuber.cnt_on(&["a"], 4)?, 0);
901
902        // Test getOnItemIter and getOnIter with duplicates
903        let mut items = Vec::new();
904        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 0)?;
905        for item_result in item_iter {
906            let (keys, on, val) = item_result?;
907            let keys_vec = keys
908                .iter()
909                .map(|k| String::from_utf8(k.clone()).unwrap())
910                .collect::<Vec<_>>();
911            items.push((keys_vec, on, val));
912        }
913        assert_eq!(items.len(), 8);
914
915        let mut vals = Vec::new();
916        let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["a"], 0)?;
917        for val_result in val_iter {
918            vals.push(val_result?);
919        }
920        assert_eq!(vals.len(), 8);
921
922        // Test getOnItemBackIter and getOnBackIter
923        let mut items = Vec::new();
924        let item_iter = onsuber.get_on_item_back_iter::<_, Vec<u8>>(&["a"], 4)?;
925        for item_result in item_iter {
926            let (keys, on, val) = item_result?;
927            let keys_vec = keys
928                .iter()
929                .map(|k| String::from_utf8(k.clone()).unwrap())
930                .collect::<Vec<_>>();
931            items.push((keys_vec, on, val));
932        }
933        assert_eq!(items.len(), 8);
934
935        let mut vals = Vec::new();
936        let val_iter = onsuber.get_on_back_iter::<_, Vec<u8>>(&["a"], 4)?;
937        for val_result in val_iter {
938            vals.push(val_result?);
939        }
940        assert_eq!(vals.len(), 8);
941
942        // Test getOnItemIter and getOnIter with specific start point
943        let mut items = Vec::new();
944        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 2)?;
945        for item_result in item_iter {
946            let (keys, on, val) = item_result?;
947            let keys_vec = keys
948                .iter()
949                .map(|k| String::from_utf8(k.clone()).unwrap())
950                .collect::<Vec<_>>();
951            items.push((keys_vec, on, val));
952        }
953        assert_eq!(items.len(), 4);
954
955        let mut vals = Vec::new();
956        let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["a"], 2)?;
957        for val_result in val_iter {
958            vals.push(val_result?);
959        }
960        assert_eq!(vals.len(), 4);
961
962        // Test getOnItemBackIter and getOnBackIter with specific start point
963        let mut items = Vec::new();
964        let item_iter = onsuber.get_on_item_back_iter::<_, Vec<u8>>(&["a"], 1)?;
965        for item_result in item_iter {
966            let (keys, on, val) = item_result?;
967            let keys_vec = keys
968                .iter()
969                .map(|k| String::from_utf8(k.clone()).unwrap())
970                .collect::<Vec<_>>();
971            items.push((keys_vec, on, val));
972        }
973        assert_eq!(items.len(), 4);
974
975        let mut vals = Vec::new();
976        let val_iter = onsuber.get_on_back_iter::<_, Vec<u8>>(&["a"], 1)?;
977        for val_result in val_iter {
978            vals.push(val_result?);
979        }
980        assert_eq!(vals.len(), 4);
981
982        // Test append with duplicates
983        assert_eq!(onsuber.append_on(&["a"], &x)?, 4);
984        assert_eq!(onsuber.cnt_on(&["a"], 0)?, 9);
985
986        // Test removal
987        assert!(onsuber.rem_on(&["a"], 1, None::<&String>)?);
988        assert!(!onsuber.rem_on(&["a"], 1, None::<&String>)?);
989        assert!(onsuber.rem_on(&["a"], 3, None::<&String>)?);
990        assert!(!onsuber.rem_on(&["a"], 3, None::<&String>)?);
991
992        assert_eq!(onsuber.cnt_on(&["a"], 0)?, 5);
993
994        // Check remaining items
995        let mut items = Vec::new();
996        let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 0)?;
997        for item_result in item_iter {
998            let (keys, on, val) = item_result?;
999            let keys_vec = keys
1000                .iter()
1001                .map(|k| String::from_utf8(k.clone()).unwrap())
1002                .collect::<Vec<_>>();
1003            items.push((keys_vec, on, val));
1004        }
1005        assert_eq!(items.len(), 5);
1006
1007        Ok(())
1008    }
1009}