simple_database/
memory_store.rs

1use super::Error;
2use super::traits::KeyValueStore;
3
4use std::collections::HashMap;
5use std::path::{PathBuf, Path};
6use std::sync::Arc;
7use tokio::sync::Mutex;
8use std::sync::{LazyLock};
9
10use serde::{Serialize, Deserialize};
11
12type Store = Arc<Mutex<(Vec<PathBuf>, HashMap<Vec<u8>, Vec<u8>>)>>;
13
14static MEMORY: LazyLock<Mutex<HashMap<PathBuf, Store>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
15
16
17#[derive(Serialize, Deserialize, Debug)]
18pub struct Partitions {
19    names: Vec<String>
20}
21
22#[derive(Clone)]
23pub struct MemoryStore {
24    location: PathBuf,
25    store: Store
26}
27
28#[async_trait::async_trait]
29impl KeyValueStore for MemoryStore {
30    async fn new(location: PathBuf) -> Result<Self, Error> {
31        let mut memory = MEMORY.lock().await;
32        let store = if let Some(store) = memory.get(&location) {
33            store.clone()
34        } else {
35            let store = Arc::new(Mutex::new((vec![], HashMap::new())));
36            memory.insert(location.clone(), store.clone());
37            store
38        };
39        Ok(MemoryStore{location, store})
40    }
41
42    async fn partition(&self, location: PathBuf) -> Result<Box<dyn KeyValueStore>, Error> {
43        if let Some(ns) = self.get_partition(&location).await {Ok(ns)} else {
44            self.store.lock().await.0.push(location.clone());
45            Ok(Box::new(Self::new(self.location.join(location)).await?))
46        }
47    }
48
49    async fn get_partition(&self, location: &Path) -> Option<Box<dyn KeyValueStore>> {
50        if self.store.lock().await.0.contains(&location.to_path_buf()) {
51            Some(Box::new(Self::new(self.location.join(location)).await.unwrap()))
52        } else {None}
53    }
54
55    async fn clear(&self) -> Result<(), Error> {
56        let mut store = self.store.lock().await;
57        for loc in &store.0 {
58            Box::pin(self.get_partition(loc)).await.unwrap().clear().await?;
59        }
60        store.0.clear();
61        store.1.clear();
62        Ok(())
63    }
64    async fn delete(&self, key: &[u8]) -> Result<(), Error> {
65        self.store.lock().await.1.remove(key);
66        Ok(())
67    }
68    async fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Error> {
69        Ok(self.store.lock().await.1.get(key).cloned())
70    }
71    async fn set(&self, key: &[u8], value: &[u8]) -> Result<(), Error> {
72        self.store.lock().await.1.insert(key.to_vec(), value.to_vec());
73        Ok(())
74    }
75
76    async fn get_all(&self) -> Result<Vec<(Vec<u8>, Vec<u8>)>, Error> {
77        Ok(self.store.lock().await.1.iter().map(|(k, v)| (k.clone(), v.clone())).collect())
78    }
79    async fn keys(&self) -> Result<Vec<Vec<u8>>, Error> {
80        Ok(self.store.lock().await.1.keys().cloned().collect())
81    }
82    async fn values(&self) -> Result<Vec<Vec<u8>>, Error> {
83        Ok(self.store.lock().await.1.values().cloned().collect())
84    }
85
86    fn location(&self) -> PathBuf { self.location.clone() }
87}
88
89impl std::fmt::Debug for MemoryStore {
90    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
91        let mut fmt = f.debug_struct("MemoryStore");
92        fmt
93        .field("location", &self.location)
94        .finish()
95    }
96}
simple_database/memory_store.rs

simple_database/
memory_store.rs
