ng_repo/
kcv_storage.rs

1// Copyright (c) 2022-2025 Niko Bonnieure, Par le Peuple, NextGraph.org developers
2// Licensed under the Apache License, Version 2.0
3// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
4// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
5// at your option. All files in the project carrying such
6// notice may not be copied, modified, or distributed except
7// according to those terms.
8
9//! KeyColumnValue Storage abstraction
10
11use std::{
12    collections::{HashMap, HashSet},
13    marker::PhantomData,
14};
15
16use serde::{Deserialize, Serialize};
17use serde_bare::{from_slice, to_vec};
18
19use crate::errors::StorageError;
20#[allow(unused_imports)]
21use crate::log::*;
22
23pub fn prop<A>(prop: u8, props: &HashMap<u8, Vec<u8>>) -> Result<A, StorageError>
24where
25    A: for<'a> Deserialize<'a>,
26{
27    Ok(from_slice(
28        &props.get(&prop).ok_or(StorageError::PropertyNotFound)?,
29    )?)
30}
31
32pub fn col<A>(
33    column: &dyn ISingleValueColumn,
34    props: &HashMap<u8, Vec<u8>>,
35) -> Result<A, StorageError>
36where
37    A: for<'a> Deserialize<'a>,
38{
39    Ok(from_slice(
40        &props
41            .get(&column.suffix())
42            .ok_or(StorageError::PropertyNotFound)?,
43    )?)
44}
45
46pub struct Class<'a> {
47    prefix: Option<u8>,
48    pub name: &'static str,
49    existential_column: Option<&'a dyn ISingleValueColumn>,
50    columns: &'a [&'a dyn ISingleValueColumn],
51    multi_value_columns: &'a [&'a dyn IMultiValueColumn],
52}
53
54impl<'a> Class<'a> {
55    pub const fn new(
56        name: &'static str,
57        prefix: Option<u8>,
58        existential_column: Option<&'a dyn ISingleValueColumn>,
59        columns: &'a [&'a dyn ISingleValueColumn],
60        multi_value_columns: &'a [&'a dyn IMultiValueColumn],
61    ) -> Self {
62        if prefix.is_none() {
63            if existential_column.is_some() {
64                panic!("cannot have an existential_column without a prefix");
65            }
66            if columns.len() > 0 {
67                panic!("cannot have some property columns without a prefix");
68            }
69        }
70        Self {
71            columns,
72            name,
73            multi_value_columns,
74            prefix,
75            existential_column,
76        }
77    }
78
79    /// check unicity of prefixes and suffixes
80    #[cfg(debug_assertions)]
81    pub fn check(&self) {
82        let mut prefixes = if self.prefix.is_some() {
83            HashSet::from([self.prefix.unwrap()])
84        } else {
85            HashSet::new()
86        };
87
88        let mut suffixes = if self.existential_column.is_some() {
89            HashSet::from([self.existential_column.unwrap().suffix()])
90        } else {
91            HashSet::new()
92        };
93        let name = self.name;
94        //log_debug!("CHECKING CLASS {name}");
95        for column in self.columns.iter() {
96            //log_debug!("INSERTING SUFFIX {}", column.suffix());
97            if !suffixes.insert(column.suffix()) {
98                panic!(
99                    "duplicate suffix {} in {name}!!! check the code",
100                    column.suffix() as char
101                );
102            }
103        }
104        //log_debug!("SUFFIXES {:?}", suffixes);
105        for mvc in self.multi_value_columns.iter() {
106            //log_debug!("INSERTING PREFIX {}", mvc.prefix());
107            if !prefixes.insert(mvc.prefix()) {
108                panic!(
109                    "duplicate prefix {} in {name}!!! check the code",
110                    mvc.prefix() as char
111                );
112            }
113        }
114        //log_debug!("PREFIXES {:?}", prefixes);
115    }
116
117    pub fn prefixes(&self) -> Vec<u8> {
118        let mut res: Vec<u8> = self
119            .multi_value_columns
120            .iter()
121            .map(|c| c.prefix())
122            .collect();
123        if self.prefix.is_some() {
124            res.push(self.prefix.unwrap());
125        }
126        res
127    }
128    fn suffices(&self) -> Vec<u8> {
129        let mut res: Vec<u8> = self.columns.iter().map(|c| c.suffix()).collect();
130        if self.existential_column.is_some() {
131            res.push(self.existential_column.unwrap().suffix());
132        }
133        res
134    }
135}
136
137pub fn format_type_of<T>(_: &T) -> String {
138    format!("{}", std::any::type_name::<T>())
139}
140
141pub trait IModel {
142    fn key(&self) -> &Vec<u8>;
143    fn prefix(&self) -> u8 {
144        self.class().prefix.unwrap()
145    }
146    fn check_exists(&mut self) -> Result<(), StorageError> {
147        if !self.exists() {
148            return Err(StorageError::NotFound);
149        }
150        Ok(())
151    }
152    fn existential(&mut self) -> Option<&mut dyn IExistentialValue>;
153    fn exists(&mut self) -> bool {
154        if self.existential().is_none() || self.class().existential_column.is_none() {
155            return true;
156        }
157        if self.existential().as_mut().unwrap().exists() {
158            return true;
159        }
160        let prefix = self.prefix();
161        let key = self.key();
162        let suffix = self.class().existential_column.unwrap().suffix();
163        // log_info!(
164        //     "EXISTENTIAL CHECK {} {} {:?}",
165        //     prefix as char,
166        //     suffix as char,
167        //     key
168        // );
169        match self.storage().get(prefix, key, Some(suffix), &None) {
170            Ok(res) => {
171                //log_info!("EXISTENTIAL CHECK GOT {:?}", res);
172                self.existential().as_mut().unwrap().process_exists(res);
173                true
174            }
175            Err(_e) => false,
176        }
177    }
178    fn storage(&self) -> &dyn KCVStorage;
179    fn load_props(&self) -> Result<HashMap<u8, Vec<u8>>, StorageError> {
180        if self.class().prefix.is_none() {
181            panic!("cannot call load_props on a Class without prefix");
182        }
183        self.storage().get_all_properties_of_key(
184            self.prefix(),
185            self.key().to_vec(),
186            self.class().suffices(),
187            &None,
188        )
189    }
190    fn class(&self) -> &Class;
191    fn del(&self) -> Result<(), StorageError> {
192        self.storage().write_transaction(&mut |tx| {
193            if self.class().prefix.is_some() {
194                tx.del_all(self.prefix(), self.key(), &self.class().suffices(), &None)?;
195            }
196            for mvc in self.class().multi_value_columns.iter() {
197                let size = mvc.value_size()?;
198                tx.del_all_values(mvc.prefix(), self.key(), size, None, &None)?;
199            }
200            Ok(())
201        })?;
202        Ok(())
203    }
204}
205use std::hash::Hash;
206pub struct MultiValueColumn<
207    Model: IModel,
208    Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'a> Deserialize<'a>,
209> {
210    prefix: u8,
211    phantom: PhantomData<Column>,
212    model: PhantomData<Model>,
213    //value_size: usize,
214}
215
216impl<
217        Model: IModel,
218        Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'d> Deserialize<'d>,
219    > MultiValueColumn<Model, Column>
220{
221    pub const fn new(prefix: u8) -> Self {
222        MultiValueColumn {
223            prefix,
224            phantom: PhantomData,
225            model: PhantomData,
226        }
227    }
228
229    fn compute_key(model: &Model, column: &Column) -> Result<Vec<u8>, StorageError> {
230        let model_key = model.key();
231        let mut column_ser = to_vec(column)?;
232        let mut key = Vec::with_capacity(model_key.len() + column_ser.len());
233        key.append(&mut model_key.to_vec());
234        key.append(&mut column_ser);
235        Ok(key)
236    }
237
238    pub fn add(&self, model: &mut Model, column: &Column) -> Result<(), StorageError> {
239        model.check_exists()?;
240        let key = Self::compute_key(model, column)?;
241        model.storage().put(self.prefix, &key, None, &vec![], &None)
242    }
243
244    pub fn add_lazy(&self, model: &mut Model, column: &Column) -> Result<(), StorageError> {
245        model.check_exists()?;
246        let key = Self::compute_key(model, column)?;
247        model.storage().write_transaction(&mut |tx| {
248            match tx.has_property_value(self.prefix, &key, None, &vec![], &None) {
249                Ok(_) => {}
250                Err(StorageError::NotFound) => {
251                    tx.put(self.prefix, &key, None, &vec![], &None)?;
252                }
253                Err(e) => return Err(e),
254            };
255            Ok(())
256        })
257    }
258
259    pub fn remove(&self, model: &mut Model, column: &Column) -> Result<(), StorageError> {
260        model.check_exists()?;
261        let key = Self::compute_key(model, column)?;
262        model.storage().del(self.prefix, &key, None, &None)
263    }
264
265    pub fn has(&self, model: &mut Model, column: &Column) -> Result<(), StorageError> {
266        model.check_exists()?;
267        let key = Self::compute_key(model, column)?;
268        model
269            .storage()
270            .has_property_value(self.prefix, &key, None, &vec![], &None)
271    }
272
273    pub fn remove_from_set_and_add(
274        &self,
275        model: &mut Model,
276        mut remove_set: HashSet<Column>,
277        add_set: HashSet<Column>,
278    ) -> Result<(), StorageError> {
279        // if existing_set.len() == 0 {
280        //     return Err(StorageError::InvalidValue);
281        // }
282        model.check_exists()?;
283
284        let key_prefix = model.key();
285        let key_prefix_len = key_prefix.len();
286        let total_size = key_prefix_len + self.value_size()?;
287
288        //log_debug!("REPLACE HEAD {:?} with {:?}", existing_set, replace_with);
289
290        model.storage().write_transaction(&mut |tx| {
291            for found in tx.get_all_keys_and_values(
292                self.prefix,
293                total_size,
294                key_prefix.to_vec(),
295                None,
296                &None,
297            )? {
298                if found.0.len() == total_size + 1 {
299                    let val: Column = from_slice(&found.0[1 + key_prefix_len..total_size + 1])?;
300                    if remove_set.remove(&val) {
301                        tx.del(self.prefix, &found.0[1..].to_vec(), None, &None)?;
302                    }
303                }
304            }
305
306            for add in add_set.iter() {
307                let mut new = Vec::with_capacity(total_size);
308                new.extend(key_prefix);
309                let mut val = to_vec(add)?;
310                new.append(&mut val);
311                //log_debug!("PUTTING HEAD {} {:?}", self.prefix as char, new);
312                tx.put(self.prefix, &new, None, &vec![], &None)?;
313            }
314            return Ok(());
315        })
316    }
317
318    pub fn replace_with_new_set_if_old_set_exists(
319        &self,
320        model: &mut Model,
321        mut existing_set: HashSet<Column>,
322        replace_with: HashSet<Column>,
323    ) -> Result<(), StorageError> {
324        // if existing_set.len() == 0 {
325        //     return Err(StorageError::InvalidValue);
326        // }
327        model.check_exists()?;
328
329        let key_prefix = model.key();
330        let key_prefix_len = key_prefix.len();
331        let total_size = key_prefix_len + self.value_size()?;
332
333        let empty_existing = existing_set.is_empty();
334
335        //log_debug!("REPLACE HEAD {:?} with {:?}", existing_set, replace_with);
336
337        model.storage().write_transaction(&mut |tx| {
338            for found in tx.get_all_keys_and_values(
339                self.prefix,
340                total_size,
341                key_prefix.to_vec(),
342                None,
343                &None,
344            )? {
345                if found.0.len() == total_size + 1 {
346                    let val: Column = from_slice(&found.0[1 + key_prefix_len..total_size + 1])?;
347                    if empty_existing {
348                        return Err(StorageError::NotEmpty);
349                    }
350                    if existing_set.remove(&val) {
351                        tx.del(self.prefix, &found.0[1..].to_vec(), None, &None)?;
352                    }
353                }
354            }
355            if existing_set.is_empty() {
356                for add in replace_with.iter() {
357                    let mut new = Vec::with_capacity(total_size);
358                    new.extend(key_prefix);
359                    let mut val = to_vec(add)?;
360                    new.append(&mut val);
361                    //log_debug!("PUTTING HEAD {} {:?}", self.prefix as char, new);
362                    tx.put(self.prefix, &new, None, &vec![], &None)?;
363                }
364                return Ok(());
365            }
366            Err(StorageError::Abort)
367        })
368    }
369
370    pub fn get_all(&self, model: &mut Model) -> Result<HashSet<Column>, StorageError> {
371        model.check_exists()?;
372        let key_prefix = model.key();
373        let key_prefix_len = key_prefix.len();
374        let mut res: HashSet<Column> = HashSet::new();
375        let total_size = key_prefix_len + self.value_size()?;
376        for val in model.storage().get_all_keys_and_values(
377            self.prefix,
378            total_size,
379            key_prefix.to_vec(),
380            None,
381            &None,
382        )? {
383            if val.0.len() == total_size + 1 {
384                let val: Column = from_slice(&val.0[1 + key_prefix_len..total_size + 1])?;
385                res.insert(val);
386            }
387        }
388        Ok(res)
389    }
390}
391
392impl<
393        Model: IModel,
394        Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'d> Deserialize<'d>,
395    > IMultiValueColumn for MultiValueColumn<Model, Column>
396{
397    fn value_size(&self) -> Result<usize, StorageError> {
398        Ok(to_vec(&Column::default())?.len())
399    }
400    fn prefix(&self) -> u8 {
401        self.prefix
402    }
403}
404
405pub struct MultiMapColumn<
406    Model: IModel,
407    Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'a> Deserialize<'a>,
408    Value: Serialize + for<'a> Deserialize<'a> + Clone + PartialEq,
409> {
410    prefix: u8,
411    phantom_column: PhantomData<Column>,
412    phantom_model: PhantomData<Model>,
413    phantom_value: PhantomData<Value>,
414    //value_size: usize,
415}
416
417impl<
418        Model: IModel,
419        Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'d> Deserialize<'d>,
420        Value: Serialize + for<'a> Deserialize<'a> + Clone + PartialEq,
421    > MultiMapColumn<Model, Column, Value>
422{
423    pub const fn new(prefix: u8) -> Self {
424        MultiMapColumn {
425            prefix,
426            phantom_column: PhantomData,
427            phantom_model: PhantomData,
428            phantom_value: PhantomData,
429        }
430    }
431    pub fn add(
432        &self,
433        model: &mut Model,
434        column: &Column,
435        value: &Value,
436    ) -> Result<(), StorageError> {
437        model.check_exists()?;
438        let key = MultiValueColumn::compute_key(model, column)?;
439        model
440            .storage()
441            .put(self.prefix, &key, None, &to_vec(value)?, &None)
442    }
443    pub fn remove(
444        &self,
445        model: &mut Model,
446        column: &Column,
447        value: &Value,
448    ) -> Result<(), StorageError> {
449        model.check_exists()?;
450        let key = MultiValueColumn::compute_key(model, column)?;
451        model
452            .storage()
453            .del_property_value(self.prefix, &key, None, &to_vec(value)?, &None)
454    }
455    pub fn remove_regardless_value(
456        &self,
457        model: &mut Model,
458        column: &Column,
459    ) -> Result<(), StorageError> {
460        model.check_exists()?;
461        let key = MultiValueColumn::compute_key(model, column)?;
462        model.storage().del(self.prefix, &key, None, &None)
463    }
464
465    pub fn has(
466        &self,
467        model: &mut Model,
468        column: &Column,
469        value: &Value,
470    ) -> Result<(), StorageError> {
471        model.check_exists()?;
472        let key = MultiValueColumn::compute_key(model, column)?;
473        model
474            .storage()
475            .has_property_value(self.prefix, &key, None, &to_vec(value)?, &None)
476    }
477
478    pub fn get(&self, model: &mut Model, column: &Column) -> Result<Value, StorageError> {
479        model.check_exists()?;
480        let key = MultiValueColumn::compute_key(model, column)?;
481        let val_ser = model.storage().get(self.prefix, &key, None, &None)?;
482        Ok(from_slice(&val_ser)?)
483    }
484
485    pub fn get_or_add(
486        &self,
487        model: &mut Model,
488        column: &Column,
489        value: &Value,
490    ) -> Result<Value, StorageError> {
491        model.check_exists()?;
492        let key = MultiValueColumn::compute_key(model, column)?;
493        let mut found: Option<Value> = None;
494        model.storage().write_transaction(&mut |tx| {
495            found = match tx.get(self.prefix, &key, None, &None) {
496                Ok(val_ser) => Some(from_slice(&val_ser)?),
497                Err(StorageError::NotFound) => {
498                    tx.put(self.prefix, &key, None, &to_vec(value)?, &None)?;
499                    None
500                }
501                Err(e) => return Err(e),
502            };
503            Ok(())
504        })?;
505        Ok(found.unwrap_or(value.clone()))
506    }
507
508    pub fn add_or_change(
509        &self,
510        model: &mut Model,
511        column: &Column,
512        value: &Value,
513    ) -> Result<(), StorageError> {
514        model.check_exists()?;
515        let key = MultiValueColumn::compute_key(model, column)?;
516        let mut found: Option<Value> = None;
517        model.storage().write_transaction(&mut |tx| {
518            found = match tx.get(self.prefix, &key, None, &None) {
519                Ok(val_ser) => Some(from_slice(&val_ser)?),
520                Err(StorageError::NotFound) => {
521                    tx.put(self.prefix, &key, None, &to_vec(value)?, &None)?;
522                    None
523                }
524                Err(e) => return Err(e),
525            };
526            if found.is_some() && found.as_ref().unwrap() != value {
527                // we change it
528                tx.put(self.prefix, &key, None, &to_vec(value)?, &None)?;
529            }
530            Ok(())
531        })?;
532        Ok(())
533    }
534
535    pub fn get_all(&self, model: &mut Model) -> Result<HashMap<Column, Value>, StorageError> {
536        model.check_exists()?;
537        let key_prefix = model.key();
538        let key_prefix_len = key_prefix.len();
539        let mut res: HashMap<Column, Value> = HashMap::new();
540        let total_size = key_prefix_len + self.value_size()?;
541        for val in model.storage().get_all_keys_and_values(
542            self.prefix,
543            total_size,
544            key_prefix.to_vec(),
545            None,
546            &None,
547        )? {
548            if val.0.len() == total_size + 1 {
549                let col: Column = from_slice(&val.0[1 + key_prefix_len..total_size + 1])?;
550                let val = from_slice(&val.1)?;
551                res.insert(col, val);
552            }
553        }
554        Ok(res)
555    }
556}
557impl<
558        Model: IModel,
559        Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'d> Deserialize<'d>,
560        Value: Serialize + for<'a> Deserialize<'a> + Clone + PartialEq,
561    > IMultiValueColumn for MultiMapColumn<Model, Column, Value>
562{
563    fn value_size(&self) -> Result<usize, StorageError> {
564        Ok(to_vec(&Column::default())?.len())
565    }
566    fn prefix(&self) -> u8 {
567        self.prefix
568    }
569}
570
571pub struct MultiCounterColumn<
572    Model: IModel,
573    Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'a> Deserialize<'a>,
574> {
575    prefix: u8,
576    phantom_column: PhantomData<Column>,
577    phantom_model: PhantomData<Model>,
578}
579
580impl<
581        Model: IModel,
582        Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'d> Deserialize<'d>,
583    > MultiCounterColumn<Model, Column>
584{
585    pub const fn new(prefix: u8) -> Self {
586        MultiCounterColumn {
587            prefix,
588            phantom_column: PhantomData,
589            phantom_model: PhantomData,
590        }
591    }
592    pub fn increment(&self, model: &mut Model, column: &Column) -> Result<(), StorageError> {
593        let key = MultiValueColumn::compute_key(model, column)?;
594        model.storage().write_transaction(&mut |tx| {
595            let mut val: u64 = match tx.get(self.prefix, &key, None, &None) {
596                Ok(val_ser) => from_slice(&val_ser)?,
597                Err(StorageError::NotFound) => 0,
598                Err(e) => return Err(e),
599            };
600            val += 1;
601            let val_ser = to_vec(&val)?;
602            tx.put(self.prefix, &key, None, &val_ser, &None)?;
603            Ok(())
604        })
605    }
606    /// returns true if the counter reached zero (and the key was removed from KVC store)
607    pub fn decrement(&self, model: &mut Model, column: &Column) -> Result<bool, StorageError> {
608        let key = MultiValueColumn::compute_key(model, column)?;
609        let mut ret: bool = false;
610        model.storage().write_transaction(&mut |tx| {
611            let val_ser = tx.get(self.prefix, &key, None, &None)?;
612            let mut val: u64 = from_slice(&val_ser)?;
613            val -= 1;
614            ret = val == 0;
615            if ret {
616                tx.del(self.prefix, &key, None, &None)?;
617            } else {
618                let val_ser = to_vec(&val)?;
619                tx.put(self.prefix, &key, None, &val_ser, &None)?;
620            }
621            Ok(())
622        })?;
623        Ok(ret)
624    }
625
626    pub fn get(&self, model: &mut Model, column: &Column) -> Result<u64, StorageError> {
627        let key = MultiValueColumn::compute_key(model, column)?;
628        let val_ser = model.storage().get(self.prefix, &key, None, &None)?;
629        let val: u64 = from_slice(&val_ser)?;
630        Ok(val)
631    }
632
633    pub fn get_all(&self, model: &mut Model) -> Result<HashMap<Column, u64>, StorageError> {
634        model.check_exists()?;
635        let key_prefix = model.key();
636        let key_prefix_len = key_prefix.len();
637        let mut res: HashMap<Column, u64> = HashMap::new();
638        let total_size = key_prefix_len + self.value_size()?;
639        for val in model.storage().get_all_keys_and_values(
640            self.prefix,
641            total_size,
642            key_prefix.to_vec(),
643            None,
644            &None,
645        )? {
646            if val.0.len() == total_size + 1 {
647                let col: Column = from_slice(&val.0[1 + key_prefix_len..total_size + 1])?;
648                let val = from_slice(&val.1)?;
649                res.insert(col, val);
650            }
651        }
652        Ok(res)
653    }
654}
655impl<
656        Model: IModel,
657        Column: std::fmt::Debug + Eq + PartialEq + Hash + Serialize + Default + for<'d> Deserialize<'d>,
658    > IMultiValueColumn for MultiCounterColumn<Model, Column>
659{
660    fn value_size(&self) -> Result<usize, StorageError> {
661        Ok(to_vec(&(0 as u64))?.len())
662    }
663    fn prefix(&self) -> u8 {
664        self.prefix
665    }
666}
667
668pub trait ISingleValueColumn {
669    fn suffix(&self) -> u8;
670}
671
672pub trait IMultiValueColumn {
673    fn prefix(&self) -> u8;
674    fn value_size(&self) -> Result<usize, StorageError>;
675}
676
677pub struct SingleValueColumn<Model: IModel, Value: Serialize + for<'a> Deserialize<'a>> {
678    suffix: u8,
679    phantom_value: PhantomData<Value>,
680    phantom_model: PhantomData<Model>,
681}
682
683impl<Model: IModel, Value: Clone + Serialize + for<'d> Deserialize<'d>> ISingleValueColumn
684    for SingleValueColumn<Model, Value>
685{
686    fn suffix(&self) -> u8 {
687        self.suffix
688    }
689}
690
691impl<Model: IModel, Value: Clone + Serialize + for<'d> Deserialize<'d>>
692    SingleValueColumn<Model, Value>
693{
694    pub const fn new(suffix: u8) -> Self {
695        SingleValueColumn {
696            suffix,
697            phantom_value: PhantomData,
698            phantom_model: PhantomData,
699        }
700    }
701
702    pub fn set(&self, model: &mut Model, value: &Value) -> Result<(), StorageError> {
703        model.check_exists()?;
704        model.storage().replace(
705            model.prefix(),
706            model.key(),
707            Some(self.suffix),
708            &to_vec(value)?,
709            &None,
710        )
711    }
712
713    pub fn get(&self, model: &mut Model) -> Result<Value, StorageError> {
714        model.check_exists()?;
715        match model
716            .storage()
717            .get(model.prefix(), model.key(), Some(self.suffix), &None)
718        {
719            Ok(res) => Ok(from_slice::<Value>(&res)?),
720            Err(e) => Err(e),
721        }
722    }
723
724    pub fn get_or_set(&self, model: &mut Model, value: &Value) -> Result<Value, StorageError> {
725        model.check_exists()?;
726        let mut found: Option<Value> = None;
727        model.storage().write_transaction(&mut |tx| {
728            found = match tx.get(model.prefix(), model.key(), Some(self.suffix), &None) {
729                Ok(val_ser) => Some(from_slice(&val_ser)?),
730                Err(StorageError::NotFound) => {
731                    tx.put(
732                        model.prefix(),
733                        model.key(),
734                        Some(self.suffix),
735                        &to_vec(value)?,
736                        &None,
737                    )?;
738                    None
739                }
740                Err(e) => return Err(e),
741            };
742            Ok(())
743        })?;
744        Ok(found.unwrap_or(value.clone()))
745    }
746
747    pub fn has(&self, model: &mut Model, value: &Value) -> Result<(), StorageError> {
748        model.check_exists()?;
749        model.storage().has_property_value(
750            model.prefix(),
751            model.key(),
752            Some(self.suffix),
753            &to_vec(value)?,
754            &None,
755        )
756    }
757
758    pub fn del(&self, model: &mut Model) -> Result<(), StorageError> {
759        model.check_exists()?;
760        model
761            .storage()
762            .del(model.prefix(), model.key(), Some(self.suffix), &None)
763    }
764}
765
766/////////////  Counter Value
767
768pub struct CounterValue<Model: IModel> {
769    suffix: u8,
770    phantom_model: PhantomData<Model>,
771}
772
773impl<Model: IModel> ISingleValueColumn for CounterValue<Model> {
774    fn suffix(&self) -> u8 {
775        self.suffix
776    }
777}
778
779impl<Model: IModel> CounterValue<Model> {
780    pub const fn new(suffix: u8) -> Self {
781        CounterValue {
782            suffix,
783            phantom_model: PhantomData,
784        }
785    }
786
787    pub fn increment(&self, model: &mut Model) -> Result<(), StorageError> {
788        model.storage().write_transaction(&mut |tx| {
789            let mut val: u64 = match tx.get(model.prefix(), model.key(), Some(self.suffix), &None) {
790                Ok(val_ser) => from_slice(&val_ser)?,
791                Err(StorageError::NotFound) => 0,
792                Err(e) => return Err(e),
793            };
794            val += 1;
795            let val_ser = to_vec(&val)?;
796            tx.put(
797                model.prefix(),
798                model.key(),
799                Some(self.suffix),
800                &val_ser,
801                &None,
802            )?;
803            Ok(())
804        })
805    }
806    /// returns true if the counter reached zero, and the property was removed
807    pub fn decrement(&self, model: &mut Model) -> Result<bool, StorageError> {
808        let mut ret: bool = false;
809        model.storage().write_transaction(&mut |tx| {
810            let val_ser = tx.get(model.prefix(), model.key(), Some(self.suffix), &None)?;
811            let mut val: u64 = from_slice(&val_ser)?;
812            val -= 1;
813            ret = val == 0;
814            if ret {
815                tx.del(model.prefix(), model.key(), Some(self.suffix), &None)?;
816            } else {
817                let val_ser = to_vec(&val)?;
818                tx.put(
819                    model.prefix(),
820                    model.key(),
821                    Some(self.suffix),
822                    &val_ser,
823                    &None,
824                )?;
825            }
826            Ok(())
827        })?;
828        Ok(ret)
829    }
830
831    pub fn get(&self, model: &mut Model) -> Result<u64, StorageError> {
832        let val_res = model
833            .storage()
834            .get(model.prefix(), model.key(), Some(self.suffix), &None);
835        match val_res {
836            Ok(val_ser) => Ok(from_slice(&val_ser)?),
837            Err(StorageError::NotFound) => Ok(0),
838            Err(e) => Err(e),
839        }
840    }
841
842    pub fn del(&self, model: &mut Model) -> Result<(), StorageError> {
843        model.check_exists()?;
844        model
845            .storage()
846            .del(model.prefix(), model.key(), Some(self.suffix), &None)
847    }
848}
849
850////////////////
851
852pub struct ExistentialValueColumn {
853    suffix: u8,
854}
855
856impl ISingleValueColumn for ExistentialValueColumn {
857    fn suffix(&self) -> u8 {
858        self.suffix
859    }
860}
861
862impl ExistentialValueColumn {
863    pub const fn new(suffix: u8) -> Self {
864        ExistentialValueColumn { suffix }
865    }
866}
867
868pub struct ExistentialValue<Column: Serialize + for<'d> Deserialize<'d>> {
869    value: Option<Column>,
870    value_ser: Vec<u8>,
871}
872pub trait IExistentialValue {
873    fn process_exists(&mut self, value_ser: Vec<u8>);
874
875    fn exists(&self) -> bool;
876}
877
878impl<Column: Serialize + for<'d> Deserialize<'d>> IExistentialValue for ExistentialValue<Column> {
879    fn exists(&self) -> bool {
880        self.value.is_some() || self.value_ser.len() > 0
881    }
882    fn process_exists(&mut self, value_ser: Vec<u8>) {
883        self.value_ser = value_ser;
884    }
885}
886
887impl<Column: Clone + Serialize + for<'d> Deserialize<'d>> ExistentialValue<Column> {
888    pub fn new() -> Self {
889        ExistentialValue {
890            value: None,
891            value_ser: vec![],
892        }
893    }
894
895    pub fn set(&mut self, value: &Column) -> Result<(), StorageError> {
896        if self.value.is_some() {
897            return Err(StorageError::AlreadyExists);
898        }
899        self.value = Some(value.clone());
900
901        Ok(())
902    }
903
904    pub fn save<Model: IModel>(model: &Model, value: &Column) -> Result<(), StorageError> {
905        model.storage().replace(
906            model.prefix(),
907            model.key(),
908            Some(model.class().existential_column.unwrap().suffix()),
909            &to_vec(value)?,
910            &None,
911        )?;
912        Ok(())
913    }
914
915    pub fn get(&mut self) -> Result<&Column, StorageError> {
916        if self.value.is_some() {
917            return Ok(self.value.as_ref().unwrap());
918        }
919        if self.value_ser.is_empty() {
920            return Err(StorageError::BackendError);
921        }
922        let value = from_slice::<Column>(&self.value_ser);
923        match value {
924            Err(_) => return Err(StorageError::InvalidValue),
925            Ok(val) => {
926                self.value = Some(val);
927                return Ok(self.value.as_ref().unwrap());
928            }
929        }
930    }
931
932    pub fn take(mut self) -> Result<Column, StorageError> {
933        self.get()?;
934        Ok(self.value.take().unwrap())
935    }
936}
937
938pub trait WriteTransaction: ReadTransaction {
939    /// Save a property value to the store.
940    fn put(
941        &self,
942        prefix: u8,
943        key: &Vec<u8>,
944        suffix: Option<u8>,
945        value: &Vec<u8>,
946        family: &Option<String>,
947    ) -> Result<(), StorageError>;
948
949    /// Replace the property of a key (single value) to the store.
950    fn replace(
951        &self,
952        prefix: u8,
953        key: &Vec<u8>,
954        suffix: Option<u8>,
955        value: &Vec<u8>,
956        family: &Option<String>,
957    ) -> Result<(), StorageError>;
958
959    /// Delete a property from the store.
960    fn del(
961        &self,
962        prefix: u8,
963        key: &Vec<u8>,
964        suffix: Option<u8>,
965        family: &Option<String>,
966    ) -> Result<(), StorageError>;
967
968    /// Delete all properties of a key from the store.
969    fn del_all(
970        &self,
971        prefix: u8,
972        key: &Vec<u8>,
973        all_suffixes: &[u8],
974        family: &Option<String>,
975    ) -> Result<(), StorageError>;
976
977    /// Delete a specific value for a property from the store.
978    fn del_property_value(
979        &self,
980        prefix: u8,
981        key: &Vec<u8>,
982        suffix: Option<u8>,
983        value: &Vec<u8>,
984        family: &Option<String>,
985    ) -> Result<(), StorageError>;
986
987    /// Delete all properties' values of a key from the store in case the property is a multi-values one
988    fn del_all_values(
989        &self,
990        prefix: u8,
991        key: &Vec<u8>,
992        property_size: usize,
993        suffix: Option<u8>,
994        family: &Option<String>,
995    ) -> Result<(), StorageError>;
996}
997
998pub trait ReadTransaction {
999    /// Load a property from the store.
1000    fn get(
1001        &self,
1002        prefix: u8,
1003        key: &Vec<u8>,
1004        suffix: Option<u8>,
1005        family: &Option<String>,
1006    ) -> Result<Vec<u8>, StorageError>;
1007
1008    /// Load all the values of a property from the store.
1009    #[deprecated(
1010        note = "KVStore has unique values (since switch from lmdb to rocksdb) use get() instead"
1011    )]
1012    fn get_all(
1013        &self,
1014        prefix: u8,
1015        key: &Vec<u8>,
1016        suffix: Option<u8>,
1017        family: &Option<String>,
1018    ) -> Result<Vec<Vec<u8>>, StorageError>;
1019
1020    fn get_all_properties_of_key(
1021        &self,
1022        prefix: u8,
1023        key: Vec<u8>,
1024        properties: Vec<u8>,
1025        family: &Option<String>,
1026    ) -> Result<HashMap<u8, Vec<u8>>, StorageError>;
1027
1028    /// Check if a specific value exists for a property from the store.
1029    fn has_property_value(
1030        &self,
1031        prefix: u8,
1032        key: &Vec<u8>,
1033        suffix: Option<u8>,
1034        value: &Vec<u8>,
1035        family: &Option<String>,
1036    ) -> Result<(), StorageError>;
1037
1038    /// retrieves all the keys and values with the given prefix and key_size. if no suffix is specified, then all (including none) the suffices are returned
1039    fn get_all_keys_and_values(
1040        &self,
1041        prefix: u8,
1042        key_size: usize,
1043        key_prefix: Vec<u8>,
1044        suffix: Option<u8>,
1045        family: &Option<String>,
1046    ) -> Result<Vec<(Vec<u8>, Vec<u8>)>, StorageError>;
1047}
1048
1049pub trait KCVStorage: WriteTransaction {
1050    fn write_transaction(
1051        &self,
1052        method: &mut dyn FnMut(&mut dyn WriteTransaction) -> Result<(), StorageError>,
1053    ) -> Result<(), StorageError>;
1054
1055    // /// Save a property value to the store.
1056    // fn put(
1057    //     &self,
1058    //     prefix: u8,
1059    //     key: &Vec<u8>,
1060    //     suffix: Option<u8>,
1061    //     value: Vec<u8>,
1062    // ) -> Result<(), StorageError>;
1063
1064    // /// Replace the property of a key (single value) to the store.
1065    // fn replace(
1066    //     &self,
1067    //     prefix: u8,
1068    //     key: &Vec<u8>,
1069    //     suffix: Option<u8>,
1070    //     value: Vec<u8>,
1071    // ) -> Result<(), StorageError>;
1072
1073    // /// Delete a property from the store.
1074    // fn del(&self, prefix: u8, key: &Vec<u8>, suffix: Option<u8>) -> Result<(), StorageError>;
1075
1076    // /// Delete all properties of a key from the store.
1077    // fn del_all(&self, prefix: u8, key: &Vec<u8>, all_suffixes: &[u8]) -> Result<(), StorageError>;
1078
1079    // /// Delete a specific value for a property from the store.
1080    // fn del_property_value(
1081    //     &self,
1082    //     prefix: u8,
1083    //     key: &Vec<u8>,
1084    //     suffix: Option<u8>,
1085    //     value: Vec<u8>,
1086    // ) -> Result<(), StorageError>;
1087}
ng_repo/kcv_storage.rs

ng_repo/
kcv_storage.rs
