1use crate::cesr::Parsable;
2use crate::keri::db::dbing::LMDBer;
3use crate::keri::db::subing::catcesr::CatCesrSuberBase;
4use crate::keri::db::subing::ioset::IoSetSuber;
5use crate::keri::db::subing::SuberError;
6use crate::Matter;
7use std::sync::Arc;
8
9pub struct CatCesrIoSetSuber<M: Matter> {
10 pub base: CatCesrSuberBase<M>,
11 pub io_set_suber: IoSetSuber,
12}
13
14impl<M: Matter + Parsable> CatCesrIoSetSuber<M> {
15 pub fn new(
16 db: Arc<LMDBer>,
17 subkey: &str,
18 formats: Vec<String>,
19 sep: Option<u8>,
20 verify: bool,
21 ) -> Result<Self, SuberError> {
22 let base = CatCesrSuberBase::new(db.clone(), subkey, formats, sep, verify)?;
23 let io_set_suber = IoSetSuber::new(db, subkey, sep, verify)?;
24
25 Ok(Self { base, io_set_suber })
26 }
27
28 pub fn ser(&self, val: &[&dyn Matter]) -> Result<Vec<u8>, SuberError> {
30 self.base.ser(val)
31 }
32
33 pub fn des(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
34 self.base.des(val)
35 }
36
37 pub fn put<K: AsRef<[u8]>>(
39 &self,
40 keys: &[K],
41 vals: &[&dyn Matter],
42 ) -> Result<bool, SuberError> {
43 let sval = self.ser(vals)?;
44 let sbuf = vec![&sval];
45 self.io_set_suber.put(keys, &sbuf)
46 }
47
48 pub fn add<K: AsRef<[u8]>>(
49 &self,
50 keys: &[K],
51 vals: &[&dyn Matter],
52 ) -> Result<bool, SuberError> {
53 let sval = self.ser(vals)?;
54 self.io_set_suber.add(keys, &sval)
55 }
56
57 pub fn pin<K: AsRef<[u8]>>(
58 &self,
59 keys: &[K],
60 valss: &[&[&dyn Matter]], ) -> Result<bool, SuberError> {
62 let mut sbuf = Vec::with_capacity(valss.len());
63 for vals in valss {
64 sbuf.push(self.ser(vals)?);
65 }
66 self.io_set_suber
67 .pin(keys, &sbuf.iter().collect::<Vec<_>>())
68 }
69
70 pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Vec<Vec<Box<dyn Matter>>>, SuberError> {
71 let vals = self.io_set_suber.get::<K, Vec<u8>>(keys)?;
72 let mut result = vec![];
73
74 for val in vals {
75 result.push(self.des(&val)?);
76 }
77
78 Ok(result)
79 }
80
81 pub fn get_iter<K: AsRef<[u8]>>(
82 &self,
83 keys: &[K],
84 ) -> Result<Vec<Result<Vec<Box<dyn Matter>>, SuberError>>, SuberError> {
85 let iter = self.io_set_suber.get_iter::<K, Vec<u8>>(keys)?;
87
88 let mut results = Vec::new();
90 for val_result in iter {
91 let matter_result = match val_result {
92 Ok(val) => self.des(&val),
93 Err(e) => Err(e),
94 };
95 results.push(matter_result);
96 }
97
98 Ok(results)
99 }
100
101 pub fn get_last<K: AsRef<[u8]>>(
102 &self,
103 keys: &[K],
104 ) -> Result<Option<Vec<Box<dyn Matter>>>, SuberError> {
105 match self.io_set_suber.get_last::<K, Vec<u8>>(keys)? {
106 Some(val) => {
107 let deserialized = self.des(&val)?;
108 Ok(Some(deserialized))
109 }
110 None => Ok(None),
111 }
112 }
113
114 pub fn rem<K: AsRef<[u8]>>(
115 &self,
116 keys: &[K],
117 vals: Option<&[&dyn Matter]>, ) -> Result<bool, SuberError> {
119 match vals {
120 Some(vs) => {
121 let sval = self.ser(vs)?; self.io_set_suber.rem(keys, Some(&sval))
123 }
124 None => self.io_set_suber.rem::<K, Vec<u8>>(keys, None),
125 }
126 }
127
128 pub fn cnt<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<usize, SuberError> {
129 self.io_set_suber.cnt(keys)
130 }
131
132 pub fn get_item_iter<K: AsRef<[u8]>>(
133 &self,
134 keys: &[K],
135 topive: bool,
136 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<Box<dyn Matter>>)>, SuberError> {
137 let items = self
138 .io_set_suber
139 .get_item_iter::<K, Vec<u8>>(keys, topive)?;
140 self.process_items(items)
141 }
142
143 pub fn process_items(
145 &self,
146 items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
147 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<Box<dyn Matter>>)>, SuberError> {
148 let mut result = Vec::with_capacity(items.len());
149
150 for (key, val) in items {
151 let deserialized = self.des(&val)?;
152 result.push((key, deserialized));
153 }
154
155 Ok(result)
156 }
157
158 pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
160 self.base.base.base.to_key(keys, topive)
161 }
162
163 pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
164 self.base.base.base.to_keys(key)
165 }
166
167 pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
168 self.base.base.base.trim(keys, topive)
169 }
170
171 pub fn get_full_item_iter<K: AsRef<[u8]>>(
172 &self,
173 keys: &[K],
174 topive: bool,
175 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
176 self.base.base.base.get_full_item_iter(keys, topive)
177 }
178
179 pub fn cnt_all(&self) -> Result<usize, SuberError> {
180 self.base.base.base.cnt_all()
181 }
182}
183#[cfg(test)]
184mod tests {
185 use std::sync::Arc;
186
187 use crate::cesr::diger::Diger;
188 use crate::cesr::indexing::siger::Siger;
189 use crate::cesr::seqner::Seqner;
190 use crate::keri::db::dbing::LMDBer;
191 use crate::keri::db::subing::SuberError;
192 use crate::Matter;
193
194 use super::CatCesrIoSetSuber;
195
196 #[test]
197 fn test_cat_cesr_ioset_suber() -> Result<(), SuberError> {
198 let lmdb = LMDBer::builder().temp(true).build()?;
200 let db = Arc::new(lmdb);
201
202 let formats = vec!["seqner".to_string(), "diger".to_string()];
204 let sdb =
205 CatCesrIoSetSuber::<Diger>::new(db.clone(), "bags.", formats.clone(), None, false)?;
206
207 let sqr0 = Seqner::from_sn(20);
209 assert_eq!(sqr0.qb64(), "0AAAAAAAAAAAAAAAAAAAAAAU");
210
211 let dgr0 = Diger::from_ser(b"Hello Me Maties.", None)?;
212 assert_eq!(dgr0.qb64(), "ELq6uSA62FaWKAQf2rclt4D1wRAeVwQ7hBucDG43GrsJ");
213
214 let vals0: [&dyn Matter; 2] = [&sqr0, &dgr0];
215
216 let val0b = sdb.ser(&vals0)?;
218 assert_eq!(val0b, [sqr0.qb64b(), dgr0.qb64b()].concat());
219
220 let vals = sdb.des(&val0b)?;
221 assert_eq!(vals.len(), 2);
222 assert_eq!(vals[0].qb64(), sqr0.qb64());
223 assert_eq!(vals[1].qb64(), dgr0.qb64());
224
225 let sqr1 = Seqner::from_sn(32);
227 assert_eq!(sqr1.qb64(), "0AAAAAAAAAAAAAAAAAAAAAAg");
228
229 let dgr1 = Diger::from_ser(b"Hi Guy.", None)?;
230 assert_eq!(dgr1.qb64(), "EAdfsnL-ko8ldxIZ9JL-KBTD4eMCqAAkEw4HmKFsT45C");
231
232 let vals1: [&dyn Matter; 2] = [&sqr1, &dgr1];
233
234 let sqr2 = Seqner::from_sn(1534);
235 assert_eq!(sqr2.qb64(), "0AAAAAAAAAAAAAAAAAAAAAX-");
236
237 let dgr2 = Diger::from_ser(b"Bye Bye Birdie.", None)?;
238 assert_eq!(dgr2.qb64(), "EAO4UVcSfvfoGnSzJycMiihykJyYOshsyvU_l8U5TrO2");
239
240 let vals2: [&dyn Matter; 2] = [&sqr2, &dgr2];
241
242 let keys0 = ["a", "front"];
243 let keys1 = ["ab", "side"];
244 let keys2 = ["ac", "back"];
245
246 assert!(sdb.put(&keys0, &vals0)?);
248 assert_eq!(sdb.cnt(&keys0)?, 1);
249
250 assert!(sdb.put(&keys0, &vals1)?);
251 assert_eq!(sdb.cnt(&keys0)?, 2);
252
253 let actuals = sdb.get(&keys0)?;
254 assert_eq!(actuals.len(), 2);
255
256 assert_eq!(actuals[0].len(), 2);
258 assert_eq!(actuals[0][0].qb64(), sqr0.qb64());
259 assert_eq!(actuals[0][1].qb64(), dgr0.qb64());
260
261 assert_eq!(actuals[1].len(), 2);
263 assert_eq!(actuals[1][0].qb64(), sqr1.qb64());
264 assert_eq!(actuals[1][1].qb64(), dgr1.qb64());
265
266 let actual = sdb.get_last(&keys0)?;
268 assert!(actual.is_some());
269 let actual = actual.unwrap();
270 assert_eq!(actual.len(), 2);
271 assert_eq!(actual[0].qb64(), sqr1.qb64());
272 assert_eq!(actual[1].qb64(), dgr1.qb64());
273
274 assert!(sdb.rem(&keys0, None)?);
276 let empty_results = sdb.get(&keys0)?;
277 assert_eq!(empty_results.len(), 0);
278 assert_eq!(sdb.cnt(&keys0)?, 0);
279
280 assert!(sdb.put(&keys0, &vals1)?);
282 assert!(sdb.put(&keys0, &vals0)?);
283
284 let actuals = sdb.get(&keys0)?;
285 assert_eq!(actuals.len(), 2);
286
287 assert_eq!(actuals[0].len(), 2);
289 assert_eq!(actuals[0][0].qb64(), sqr1.qb64());
290 assert_eq!(actuals[0][1].qb64(), dgr1.qb64());
291
292 assert_eq!(actuals[1].len(), 2);
294 assert_eq!(actuals[1][0].qb64(), sqr0.qb64());
295 assert_eq!(actuals[1][1].qb64(), dgr0.qb64());
296
297 let actual = sdb.get_last(&keys0)?;
299 assert!(actual.is_some());
300 let actual = actual.unwrap();
301 assert_eq!(actual.len(), 2);
302 assert_eq!(actual[0].qb64(), sqr0.qb64());
303 assert_eq!(actual[1].qb64(), dgr0.qb64());
304 let sqr2 = Seqner::from_sn(1534);
306 assert_eq!(sqr2.qb64(), "0AAAAAAAAAAAAAAAAAAAAAX-");
307
308 let dgr2 = Diger::from_ser(b"Bye Bye Birdie.", None)?;
309 assert_eq!(dgr2.qb64(), "EAO4UVcSfvfoGnSzJycMiihykJyYOshsyvU_l8U5TrO2");
310
311 let vals2: [&dyn Matter; 2] = [&sqr2, &dgr2];
312
313 assert!(sdb.add(&keys0, &vals2)?);
315
316 assert_eq!(sdb.cnt(&keys0)?, 3);
317
318 let actuals = sdb.get(&keys0)?;
319 assert_eq!(actuals.len(), 3);
320
321 assert_eq!(actuals[2].len(), 2);
323 assert_eq!(actuals[2][0].qb64(), sqr2.qb64());
324 assert_eq!(actuals[2][1].qb64(), dgr2.qb64());
325
326 assert!(sdb.pin(&keys0, &[&vals0[..], &vals1[..]])?);
328 assert_eq!(sdb.cnt(&keys0)?, 2);
329
330 let actuals = sdb.get(&keys0)?;
331 assert_eq!(actuals.len(), 2);
332
333 assert_eq!(actuals[0].len(), 2);
335 assert_eq!(actuals[0][0].qb64(), sqr0.qb64());
336 assert_eq!(actuals[0][1].qb64(), dgr0.qb64());
337
338 assert_eq!(actuals[1].len(), 2);
339 assert_eq!(actuals[1][0].qb64(), sqr1.qb64());
340 assert_eq!(actuals[1][1].qb64(), dgr1.qb64());
341
342 assert!(sdb.put(&keys1, &vals2)?);
344 assert!(sdb.put(&keys1, &vals1)?);
345 assert_eq!(sdb.cnt(&keys1)?, 2);
346
347 let actuals = sdb.get(&keys1)?;
348 assert_eq!(actuals.len(), 2);
349
350 assert_eq!(actuals[0].len(), 2);
352 assert_eq!(actuals[0][0].qb64(), sqr2.qb64());
353 assert_eq!(actuals[0][1].qb64(), dgr2.qb64());
354
355 let vals_iter = sdb.get_iter(&keys1)?;
357 let mut iter_results = Vec::new();
358
359 for val_result in vals_iter {
360 iter_results.push(val_result?);
361 }
362
363 assert_eq!(iter_results.len(), 2);
364 assert_eq!(iter_results[0][0].qb64(), sqr2.qb64());
365 assert_eq!(iter_results[0][1].qb64(), dgr2.qb64());
366 assert_eq!(iter_results[1][0].qb64(), sqr1.qb64());
367 assert_eq!(iter_results[1][1].qb64(), dgr1.qb64());
368
369 assert!(sdb.rem(&keys1, Some(&vals1[..]))?);
371 assert_eq!(sdb.cnt(&keys1)?, 1);
372
373 let actuals = sdb.get(&keys1)?;
374 assert_eq!(actuals.len(), 1);
375 assert_eq!(actuals[0][0].qb64(), sqr2.qb64());
376 assert_eq!(actuals[0][1].qb64(), dgr2.qb64());
377
378 assert!(sdb.put(&keys2, &vals0)?);
380 assert!(sdb.put(&keys2, &vals2)?);
381
382 let items = sdb.get_item_iter(&[] as &[&str], false)?;
384
385 let mut formatted_items = Vec::new();
387 for (keys, vals) in items {
388 let key_strs: Vec<String> = keys
389 .iter()
390 .map(|k| String::from_utf8_lossy(k).to_string())
391 .collect();
392
393 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
394
395 formatted_items.push((key_strs, val_qb64s));
396 }
397
398 assert_eq!(formatted_items.len(), 5);
400
401 let expected_pairs = [
403 (
404 vec!["a".to_string(), "front".to_string()],
405 vec![sqr0.qb64(), dgr0.qb64()],
406 ),
407 (
408 vec!["a".to_string(), "front".to_string()],
409 vec![sqr1.qb64(), dgr1.qb64()],
410 ),
411 (
412 vec!["ab".to_string(), "side".to_string()],
413 vec![sqr2.qb64(), dgr2.qb64()],
414 ),
415 (
416 vec!["ac".to_string(), "back".to_string()],
417 vec![sqr0.qb64(), dgr0.qb64()],
418 ),
419 (
420 vec!["ac".to_string(), "back".to_string()],
421 vec![sqr2.qb64(), dgr2.qb64()],
422 ),
423 ];
424
425 for expected in &expected_pairs {
427 assert!(
428 formatted_items
429 .iter()
430 .any(|item| { item.0 == expected.0 && item.1 == expected.1 }),
431 "Expected item not found: {:?}",
432 expected
433 );
434 }
435
436 let full_items = sdb.get_full_item_iter(&[] as &[&str], false)?;
438 assert_eq!(full_items.len(), 5);
439
440 let mut formatted_full_items = Vec::new();
442 for (keys, val) in full_items {
443 let key_strs: Vec<String> = keys
445 .iter()
446 .map(|k| String::from_utf8_lossy(k).to_string())
447 .collect();
448
449 let vals = sdb.des(&val)?;
451 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
452
453 formatted_full_items.push((key_strs, val_qb64s));
454 }
455
456 for (keys, _) in &formatted_full_items {
458 assert_eq!(keys.len(), 3, "Full item keys should have 3 parts");
459 assert!(
460 keys[2].starts_with("00000000000000000000000000000"),
461 "Third key part should be an ordinal: {}",
462 keys[2]
463 );
464 }
465
466 let items = sdb.get_item_iter(&keys0, false)?;
468
469 let mut formatted_items = Vec::new();
470 for (keys, vals) in items {
471 let key_strs: Vec<String> = keys
472 .iter()
473 .map(|k| String::from_utf8_lossy(k).to_string())
474 .collect();
475
476 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
477
478 formatted_items.push((key_strs, val_qb64s));
479 }
480
481 assert_eq!(formatted_items.len(), 2);
482 assert!(formatted_items.iter().any(|item| {
484 item.0 == vec!["a".to_string(), "front".to_string()]
485 && item.1 == vec![sqr0.qb64(), dgr0.qb64()]
486 }));
487 assert!(formatted_items.iter().any(|item| {
488 item.0 == vec!["a".to_string(), "front".to_string()]
489 && item.1 == vec![sqr1.qb64(), dgr1.qb64()]
490 }));
491
492 let topkeys = ["a", ""];
494 let items = sdb.get_item_iter(&topkeys, false)?;
495
496 let mut formatted_items = Vec::new();
497 for (keys, vals) in items {
498 let key_strs: Vec<String> = keys
499 .iter()
500 .map(|k| String::from_utf8_lossy(k).to_string())
501 .collect();
502
503 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
504
505 formatted_items.push((key_strs, val_qb64s));
506 }
507
508 assert_eq!(formatted_items.len(), 2);
510 for item in &formatted_items {
511 assert_eq!(item.0[0], "a");
512 assert_eq!(item.0[1], "front");
513 }
514
515 let items = sdb.get_full_item_iter(&topkeys, true)?;
517 let mut vals_count = 0;
518
519 for (keys, val) in &items {
521 let key_parts: Vec<String> = keys
522 .iter()
523 .map(|k| String::from_utf8_lossy(k).to_string())
524 .collect();
525
526 assert_eq!(key_parts[0], "a");
528
529 vals_count += 1;
531 }
532
533 assert_eq!(vals_count, 2);
535
536 assert!(sdb.trim(&["ab", ""], false)?);
538
539 let items = sdb.get_item_iter(&keys1, false)?;
541 assert_eq!(items.len(), 0);
542
543 let items = sdb.get_item_iter(&[] as &[&str], false)?;
545 let mut formatted_items = Vec::new();
546 for (keys, vals) in items {
547 let key_strs: Vec<String> = keys
548 .iter()
549 .map(|k| String::from_utf8_lossy(k).to_string())
550 .collect();
551
552 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
553
554 formatted_items.push((key_strs, val_qb64s));
555 }
556
557 assert_eq!(formatted_items.len(), 4);
559
560 let mut has_keys0 = false;
562 let mut has_keys2 = false;
563 for (keys, _) in &formatted_items {
564 if keys[0] == "a" && keys[1] == "front" {
565 has_keys0 = true;
566 } else if keys[0] == "ac" && keys[1] == "back" {
567 has_keys2 = true;
568 }
569 }
570 assert!(has_keys0, "Keys0 entries should still exist after trim");
571 assert!(has_keys2, "Keys2 entries should still exist after trim");
572
573 assert!(sdb.trim(&["a"], true)?);
575
576 let items = sdb.get_item_iter(&[] as &[&str], false)?;
578 let mut formatted_items = Vec::new();
579 for (keys, vals) in items {
580 let key_strs: Vec<String> = keys
581 .iter()
582 .map(|k| String::from_utf8_lossy(k).to_string())
583 .collect();
584
585 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
586
587 formatted_items.push((key_strs, val_qb64s));
588 }
589
590 assert_eq!(formatted_items.len(), 2);
592 for (keys, _) in &formatted_items {
593 assert_eq!(keys[0], "ac");
594 assert_eq!(keys[1], "back");
595 }
596
597 assert!(sdb.put(&["b", "1"], &vals0)?);
599 assert!(sdb.put(&["b", "2"], &vals1)?);
600 assert!(sdb.put(&["bc", "3"], &vals2)?);
601 assert!(sdb.put(&["ac", "4"], &vals0)?);
602
603 let items = sdb.get_item_iter(&[] as &[&str], false)?;
605 assert_eq!(items.len(), 6);
606
607 assert!(sdb.trim(&["b", ""], false)?);
609
610 let items = sdb.get_item_iter(&[] as &[&str], false)?;
612 let mut formatted_items = Vec::new();
613 for (keys, vals) in items {
614 let key_strs: Vec<String> = keys
615 .iter()
616 .map(|k| String::from_utf8_lossy(k).to_string())
617 .collect();
618
619 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
620
621 formatted_items.push((key_strs, val_qb64s));
622 }
623
624 assert_eq!(formatted_items.len(), 4);
626
627 for (keys, _) in &formatted_items {
629 assert!(keys[0] != "b", "Entries with 'b' prefix should be removed");
630 }
631
632 assert!(sdb.trim(&[] as &[&str], false)?);
634 let items = sdb.get_item_iter(&[] as &[&str], false)?;
635 assert_eq!(items.len(), 0, "All entries should be removed");
636
637 let sqr0 = Seqner::from_sn(20);
639 assert_eq!(sqr0.qb64(), "0AAAAAAAAAAAAAAAAAAAAAAU");
640
641 let dgr0 = Diger::from_ser(b"Hello Me Maties.", None)?;
642 assert_eq!(dgr0.qb64(), "ELq6uSA62FaWKAQf2rclt4D1wRAeVwQ7hBucDG43GrsJ");
643
644 let vals0: [&dyn Matter; 2] = [&sqr0, &dgr0];
645
646 let sqr1 = Seqner::from_sn(32);
647 assert_eq!(sqr1.qb64(), "0AAAAAAAAAAAAAAAAAAAAAAg");
648
649 let dgr1 = Diger::from_ser(b"Hi Guy.", None)?;
650 assert_eq!(dgr1.qb64(), "EAdfsnL-ko8ldxIZ9JL-KBTD4eMCqAAkEw4HmKFsT45C");
651
652 let vals1: [&dyn Matter; 2] = [&sqr1, &dgr1];
653
654 let sqr2 = Seqner::from_sn(1534);
655 assert_eq!(sqr2.qb64(), "0AAAAAAAAAAAAAAAAAAAAAX-");
656
657 let dgr2 = Diger::from_ser(b"Bye Bye Birdie.", None)?;
658 assert_eq!(dgr2.qb64(), "EAO4UVcSfvfoGnSzJycMiihykJyYOshsyvU_l8U5TrO2");
659
660 let vals2: [&dyn Matter; 2] = [&sqr2, &dgr2];
661
662 let keys0 = ["a", "front"];
664 let keys1 = ["ab", "side"];
665 let keys2 = ["ac", "back"];
666
667 sdb.put(&keys0, &vals0)?;
669 sdb.put(&keys0, &vals1)?;
670 sdb.put(&keys1, &vals2)?;
671 sdb.put(&keys2, &vals0)?;
672 sdb.put(&keys2, &vals2)?;
673
674 println!("DEBUG - Database state after insertion: keys0 count = {}, keys1 count = {}, keys2 count = {}",
676 sdb.cnt(&keys0)?, sdb.cnt(&keys1)?, sdb.cnt(&keys2)?);
677
678 let items = sdb.get_item_iter(&[] as &[&str], false)?;
680 println!("DEBUG - get_item_iter returned {} items", items.len());
681
682 let mut formatted_items = Vec::new();
684 for (keys, vals) in items {
685 let key_strs: Vec<String> = keys
686 .iter()
687 .map(|k| String::from_utf8_lossy(k).to_string())
688 .collect();
689
690 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
691
692 println!("DEBUG - Item: keys={:?}, vals={:?}", key_strs, val_qb64s);
693 formatted_items.push((key_strs, val_qb64s));
694 }
695
696 assert_eq!(formatted_items.len(), 5);
698
699 let items = sdb.get_item_iter(&keys1, false)?;
701
702 let mut formatted_items = Vec::new();
703 for (keys, vals) in items {
704 let key_strs: Vec<String> = keys
705 .iter()
706 .map(|k| String::from_utf8_lossy(k).to_string())
707 .collect();
708
709 let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
710
711 formatted_items.push((key_strs, val_qb64s));
712 }
713
714 assert_eq!(formatted_items.len(), 1);
715 assert_eq!(
716 formatted_items[0].0,
717 vec!["ab".to_string(), "side".to_string()]
718 );
719 assert_eq!(formatted_items[0].1, vec![sqr2.qb64(), dgr2.qb64()]);
720
721 let items = sdb.get_full_item_iter(&["a", ""], true)?;
723
724 assert!(items.len() >= 2); let formats2 = vec!["siger".to_string()];
727 let sdb_siger =
729 CatCesrIoSetSuber::<Siger>::new(db.clone(), "pigs.", formats2, None, false)?;
730
731 let sig0_qb64 = "AACdI8OSQkMJ9r-xigjEByEjIua7LHH3AOJ22PQKqljMhuhcgh9nGRcKnsz5KvKd7K_H9-1298F4Id1DxvIoEmCQ";
732 let val0 = Siger::from_qb64(sig0_qb64, None)?;
733
734 let siger_keys = ["zeta", "cat"];
735 assert!(sdb_siger.put(&siger_keys, &[&val0])?);
736
737 let actuals = sdb_siger.get(&siger_keys)?;
738 assert_eq!(actuals.len(), 1);
739 assert_eq!(actuals[0].len(), 1);
740 assert_eq!(actuals[0][0].qb64(), sig0_qb64);
741
742 Ok(())
744 }
745}