agdb/db/
db_key_value.rs

1use crate::DbError;
2use crate::DbValue;
3use crate::StorageData;
4use crate::collections::vec::DbVec;
5use crate::collections::vec::VecValue;
6use crate::db::db_value_index::DbValueIndex;
7use crate::storage::Storage;
8use crate::storage::StorageIndex;
9use crate::utilities::serialize::Serialize;
10use crate::utilities::serialize::SerializeStatic;
11
12/// Database key-value pair (aka property) attached to
13/// database elements. It can be constructed from a
14/// tuple of types that are convertible to `DbValue`.
15#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
16#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
18#[cfg_attr(feature = "derive", derive(agdb::AgdbDeSerialize))]
19#[cfg_attr(feature = "api", derive(agdb::api::ApiDef))]
20pub struct DbKeyValue {
21    /// Key of the property
22    pub key: DbValue,
23
24    /// Value of the property
25    pub value: DbValue,
26}
27
28pub struct DbKeyValues<S: StorageData>(DbVec<StorageIndex, S>);
29
30impl<S: StorageData> DbKeyValues<S> {
31    pub fn new(storage: &mut Storage<S>) -> Result<Self, DbError> {
32        Ok(Self(DbVec::new(storage)?))
33    }
34
35    pub fn from_storage(storage: &Storage<S>, index: StorageIndex) -> Result<Self, DbError> {
36        Ok(Self(DbVec::from_storage(storage, index)?))
37    }
38
39    pub fn storage_index(&self) -> StorageIndex {
40        self.0.storage_index()
41    }
42
43    pub fn len(&self) -> u64 {
44        self.0.len()
45    }
46
47    pub fn insert_value(
48        &mut self,
49        storage: &mut Storage<S>,
50        index: u64,
51        value: &DbKeyValue,
52    ) -> Result<(), DbError> {
53        if self.0.len() <= index {
54            self.0
55                .resize(storage, index + 1, &StorageIndex::default())?;
56        }
57
58        let storage_index = self.0.value(storage, index)?;
59
60        let mut kvs = if storage_index.0 == 0 {
61            let kvs = DbVec::<DbKeyValue, S>::new(storage)?;
62            self.0.replace(storage, index, &kvs.storage_index())?;
63            kvs
64        } else {
65            DbVec::from_storage(storage, storage_index)?
66        };
67
68        kvs.push(storage, value)
69    }
70
71    pub fn insert_or_replace(
72        &mut self,
73        storage: &mut Storage<S>,
74        index: u64,
75        value: &DbKeyValue,
76    ) -> Result<Option<DbKeyValue>, DbError> {
77        if !self.valid_index(storage, index)? {
78            self.insert_value(storage, index, value)?;
79            return Ok(None);
80        }
81
82        let mut kvs = self.kvs(storage, index)?;
83
84        if let Some((index, kv)) = kvs
85            .iter(storage)
86            .enumerate()
87            .find(|(_, kv)| kv.key == value.key)
88        {
89            kvs.replace(storage, index as u64, value)?;
90            Ok(Some(kv))
91        } else {
92            kvs.push(storage, value)?;
93            Ok(None)
94        }
95    }
96
97    pub fn key_count(&self, storage: &Storage<S>, index: u64) -> Result<u64, DbError> {
98        if !self.valid_index(storage, index)? {
99            return Ok(0);
100        }
101
102        Ok(self.kvs(storage, index)?.len())
103    }
104
105    pub fn keys(&self, storage: &Storage<S>, index: u64) -> Result<Vec<DbValue>, DbError> {
106        if !self.valid_index(storage, index)? {
107            return Ok(vec![]);
108        }
109
110        let kvs = self.kvs(storage, index)?;
111        Ok(kvs.iter(storage).map(|kv| kv.key).collect())
112    }
113
114    pub fn remove(&mut self, storage: &mut Storage<S>, index: u64) -> Result<(), DbError> {
115        if !self.valid_index(storage, index)? {
116            return Ok(());
117        }
118
119        let kvs = self.kvs(storage, index)?;
120        kvs.remove_from_storage(storage)?;
121
122        if self.0.len() - 1 == index {
123            self.0.remove(storage, index)?;
124        } else {
125            self.0.replace(storage, index, &StorageIndex::default())?;
126        }
127
128        Ok(())
129    }
130
131    pub fn remove_value(
132        &mut self,
133        storage: &mut Storage<S>,
134        index: u64,
135        key: &DbValue,
136    ) -> Result<(), DbError> {
137        if !self.valid_index(storage, index)? {
138            return Ok(());
139        }
140
141        let mut kvs = self.kvs(storage, index)?;
142
143        if let Some((index, _)) = kvs.iter(storage).enumerate().find(|(_, kv)| kv.key == *key) {
144            kvs.remove(storage, index as u64)?;
145        }
146
147        Ok(())
148    }
149
150    pub fn value(
151        &self,
152        storage: &Storage<S>,
153        index: u64,
154        key: &DbValue,
155    ) -> Result<Option<DbValue>, DbError> {
156        if !self.valid_index(storage, index)? {
157            return Ok(None);
158        }
159
160        let kvs = self.kvs(storage, index)?;
161        Ok(kvs
162            .iter(storage)
163            .find(|kv| kv.key == *key)
164            .map(|kv| kv.value))
165    }
166
167    pub fn values(&self, storage: &Storage<S>, index: u64) -> Result<Vec<DbKeyValue>, DbError> {
168        if !self.valid_index(storage, index)? {
169            return Ok(vec![]);
170        }
171
172        let kvs = self.kvs(storage, index)?;
173        Ok(kvs.iter(storage).collect())
174    }
175
176    pub fn values_by_keys(
177        &self,
178        storage: &Storage<S>,
179        index: u64,
180        keys: &[DbValue],
181    ) -> Result<Vec<DbKeyValue>, DbError> {
182        if !self.valid_index(storage, index)? {
183            return Ok(vec![]);
184        }
185
186        let kvs = self.kvs(storage, index)?;
187        let mut values = kvs
188            .iter(storage)
189            .filter_map(|kv| keys.iter().position(|k| k == &kv.key).map(|pos| (pos, kv)))
190            .collect::<Vec<_>>();
191        values.sort_by_key(|(i, _)| *i);
192        Ok(values.into_iter().map(|(_, kv)| kv).collect())
193    }
194
195    fn kvs(&self, storage: &Storage<S>, index: u64) -> Result<DbVec<DbKeyValue, S>, DbError> {
196        let storage_index = self.0.value(storage, index)?;
197        DbVec::from_storage(storage, storage_index)
198    }
199
200    fn valid_index(&self, storage: &Storage<S>, index: u64) -> Result<bool, DbError> {
201        Ok(index < self.0.len() && self.0.value(storage, index)?.0 != 0)
202    }
203}
204
205impl<K, T> From<(K, T)> for DbKeyValue
206where
207    K: Into<DbValue>,
208    T: Into<DbValue>,
209{
210    fn from(value: (K, T)) -> Self {
211        DbKeyValue {
212            key: value.0.into(),
213            value: value.1.into(),
214        }
215    }
216}
217
218impl<D: StorageData> VecValue<D> for DbKeyValue {
219    fn store(&self, storage: &mut Storage<D>) -> Result<Vec<u8>, DbError> {
220        let key_index = self.key.store_db_value(storage)?;
221        let value_index = self.value.store_db_value(storage)?;
222        Ok([key_index.data(), value_index.data()].concat())
223    }
224
225    fn load(storage: &Storage<D>, bytes: &[u8]) -> Result<Self, DbError> {
226        let key_index = DbValueIndex::deserialize(bytes)?;
227        let value_index =
228            DbValueIndex::deserialize(&bytes[key_index.serialized_size() as usize..])?;
229        let key = DbValue::load_db_value(key_index, storage)?;
230        let value = DbValue::load_db_value(value_index, storage)?;
231        Ok(Self { key, value })
232    }
233
234    fn remove(storage: &mut Storage<D>, bytes: &[u8]) -> Result<(), DbError> {
235        let key_index = DbValueIndex::deserialize(bytes)?;
236        let value_index =
237            DbValueIndex::deserialize(&bytes[key_index.serialized_size() as usize..])?;
238
239        if !key_index.is_value() {
240            storage.remove(StorageIndex(key_index.index()))?;
241        }
242
243        if !value_index.is_value() {
244            storage.remove(StorageIndex(value_index.index()))?;
245        }
246
247        Ok(())
248    }
249
250    fn storage_len() -> u64 {
251        DbValueIndex::serialized_size_static() * 2
252    }
253}
254
255#[cfg(test)]
256mod tests {
257    use crate::MemoryStorage;
258
259    use super::*;
260    #[test]
261    fn derived_from_debug() {
262        let _ = format!(
263            "{:?}",
264            DbKeyValue {
265                key: DbValue::I64(0),
266                value: DbValue::I64(0)
267            }
268        );
269    }
270
271    #[test]
272    fn derived_from_partial_eq() {
273        assert_eq!(
274            DbKeyValue {
275                key: DbValue::I64(0),
276                value: DbValue::I64(0)
277            },
278            DbKeyValue {
279                key: DbValue::I64(0),
280                value: DbValue::I64(0)
281            }
282        );
283    }
284
285    #[test]
286    fn derived_from_partial_ord() {
287        let element = DbKeyValue {
288            key: DbValue::I64(0),
289            value: DbValue::I64(0),
290        };
291        let other = DbKeyValue {
292            key: DbValue::I64(0),
293            value: DbValue::I64(0),
294        };
295        assert!(element <= other);
296    }
297
298    #[test]
299    fn derived_from_ord() {
300        let element = DbKeyValue {
301            key: DbValue::I64(0),
302            value: DbValue::I64(0),
303        };
304        assert_eq!(element.cmp(&element), std::cmp::Ordering::Equal);
305    }
306
307    #[test]
308    fn db_key_values_insert() {
309        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
310        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
311        kvs.insert_value(&mut storage, 3, &("key", "value").into())
312            .unwrap();
313
314        assert_eq!(kvs.len(), 4);
315        assert_eq!(
316            kvs.values(&storage, 3).unwrap(),
317            vec![("key", "value").into()]
318        );
319    }
320
321    #[test]
322    fn db_key_values_insert_or_replace() {
323        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
324        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
325        kvs.insert_value(&mut storage, 3, &("key", "value").into())
326            .unwrap();
327        let old = kvs
328            .insert_or_replace(&mut storage, 3, &("key", "value1").into())
329            .unwrap();
330
331        assert_eq!(kvs.len(), 4);
332        assert_eq!(
333            kvs.values(&storage, 3).unwrap(),
334            vec![("key", "value1").into()]
335        );
336        assert_eq!(old, Some(("key", "value").into()));
337    }
338
339    #[test]
340    fn db_key_values_insert_multiple() {
341        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
342        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
343        kvs.insert_value(&mut storage, 3, &("key1", "value1").into())
344            .unwrap();
345        kvs.insert_value(&mut storage, 3, &("key2", "value2").into())
346            .unwrap();
347
348        assert_eq!(kvs.len(), 4);
349        assert_eq!(
350            kvs.values(&storage, 3).unwrap(),
351            vec![("key1", "value1").into(), ("key2", "value2").into()]
352        );
353    }
354
355    #[test]
356    fn db_key_values_insert_to_default_initialized() {
357        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
358        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
359        kvs.insert_value(&mut storage, 3, &("key", "value").into())
360            .unwrap();
361        kvs.insert_value(&mut storage, 1, &("key1", "value1").into())
362            .unwrap();
363
364        assert_eq!(kvs.len(), 4);
365        assert_eq!(
366            kvs.values(&storage, 1).unwrap(),
367            vec![("key1", "value1").into()]
368        );
369    }
370
371    #[test]
372    fn db_key_values_remove_all_values() {
373        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
374        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
375        kvs.insert_value(&mut storage, 3, &("key", "value").into())
376            .unwrap();
377        kvs.insert_value(&mut storage, 1, &("key1", "value1").into())
378            .unwrap();
379        kvs.remove(&mut storage, 1).unwrap();
380
381        assert_eq!(kvs.len(), 4);
382        assert_eq!(kvs.values(&storage, 1).unwrap(), vec![]);
383    }
384
385    #[test]
386    fn db_key_values_remove_key_value() {
387        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
388        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
389        kvs.insert_value(&mut storage, 3, &("key1", "value1").into())
390            .unwrap();
391        kvs.insert_value(&mut storage, 3, &("key2", "value2").into())
392            .unwrap();
393        kvs.insert_value(&mut storage, 3, &("key3", "value3").into())
394            .unwrap();
395        kvs.remove_value(&mut storage, 3, &"key2".into()).unwrap();
396        kvs.remove_value(&mut storage, 3, &"key10".into()).unwrap();
397        kvs.remove_value(&mut storage, 10, &"key10".into()).unwrap();
398
399        assert_eq!(kvs.len(), 4);
400        assert_eq!(
401            kvs.values(&storage, 3).unwrap(),
402            vec![("key1", "value1").into(), ("key3", "value3").into()]
403        );
404    }
405
406    #[test]
407    fn db_key_values_keys() {
408        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
409        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
410        kvs.insert_value(&mut storage, 3, &("key1", "value1").into())
411            .unwrap();
412        kvs.insert_value(&mut storage, 3, &("key2", "value2").into())
413            .unwrap();
414        kvs.insert_value(&mut storage, 3, &("key3", "value3").into())
415            .unwrap();
416
417        assert_eq!(
418            kvs.keys(&storage, 3).unwrap(),
419            vec!["key1".into(), "key2".into(), "key3".into()]
420        );
421        assert_eq!(kvs.key_count(&storage, 3).unwrap(), 3);
422        assert_eq!(kvs.keys(&storage, 1).unwrap(), vec![]);
423        assert_eq!(kvs.key_count(&storage, 1).unwrap(), 0);
424    }
425
426    #[test]
427    fn db_key_values_value() {
428        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
429        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
430        kvs.insert_value(&mut storage, 3, &("key1", "value1").into())
431            .unwrap();
432        kvs.insert_value(&mut storage, 3, &("key2", "value2").into())
433            .unwrap();
434        kvs.insert_value(&mut storage, 3, &("key3", "value3").into())
435            .unwrap();
436
437        assert_eq!(
438            kvs.value(&storage, 3, &"key1".into()).unwrap(),
439            Some("value1".into())
440        );
441        assert_eq!(
442            kvs.value(&storage, 3, &"key2".into()).unwrap(),
443            Some("value2".into())
444        );
445        assert_eq!(
446            kvs.value(&storage, 3, &"key3".into()).unwrap(),
447            Some("value3".into())
448        );
449        assert_eq!(kvs.value(&storage, 3, &"key4".into()).unwrap(), None);
450    }
451
452    #[test]
453    fn db_key_values_values() {
454        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
455        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
456        kvs.insert_value(&mut storage, 3, &("key1", "value1").into())
457            .unwrap();
458
459        assert_eq!(kvs.values(&storage, 1).unwrap(), vec![]);
460        assert_eq!(
461            kvs.values(&storage, 3).unwrap(),
462            vec![("key1", "value1").into()]
463        );
464    }
465
466    #[test]
467    fn db_key_values_values_by_keys() {
468        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
469        let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
470        kvs.insert_value(&mut storage, 3, &("key1", "value1").into())
471            .unwrap();
472        kvs.insert_value(&mut storage, 3, &("key2", "value2").into())
473            .unwrap();
474        kvs.insert_value(&mut storage, 3, &("key3", "value3").into())
475            .unwrap();
476
477        assert_eq!(
478            kvs.values_by_keys(&storage, 3, &["key3".into(), "key1".into()])
479                .unwrap(),
480            vec![("key3", "value3").into(), ("key1", "value1").into()]
481        );
482        assert_eq!(
483            kvs.values_by_keys(&storage, 3, &["key4".into()]).unwrap(),
484            vec![]
485        );
486        assert_eq!(
487            kvs.values_by_keys(&storage, 1, &["key4".into()]).unwrap(),
488            vec![]
489        );
490    }
491
492    #[test]
493    fn db_key_values_from_storage() {
494        let mut storage = Storage::<MemoryStorage>::new("test").unwrap();
495        let index;
496        {
497            let mut kvs = DbKeyValues(DbVec::new(&mut storage).unwrap());
498            kvs.insert_value(&mut storage, 3, &("key1", "value1").into())
499                .unwrap();
500            kvs.insert_value(&mut storage, 3, &("key2", "value2").into())
501                .unwrap();
502            kvs.insert_value(&mut storage, 3, &("key3", "value3").into())
503                .unwrap();
504            index = kvs.storage_index();
505        }
506        let kvs = DbKeyValues::from_storage(&storage, index).unwrap();
507        assert_eq!(kvs.len(), 4);
508    }
509}
agdb/db/db_key_value.rs

agdb/db/
db_key_value.rs
