crystal 0.0.0

Crystal, a simple database.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use std::collections::HashMap;
use std::fs;
use std::path::Path;
use bincode::{serialize, deserialize};
use std::io::{Error, ErrorKind};

#[derive(Debug)]
pub struct KvStore {
    keys: HashMap<String, String>,
    storage_path: String,
}

impl KvStore {
    pub fn new(storage_path: &str) -> Result<KvStore, Error> {
        fs::create_dir_all(storage_path)?;
        Ok(KvStore {
            keys: HashMap::new(),
            storage_path: storage_path.to_string(),
        })
    }

    pub fn set(&mut self, key: String, value: String) -> Result<(), Error> {
        let file_path = format!("{}/{}.bin", self.storage_path, key);
        let encoded: Vec<u8> = serialize(&value).map_err(|e| Error::new(ErrorKind::Other, e))?;
        fs::write(file_path, encoded)?;
        self.keys.insert(key, value);
        Ok(())
    }

    pub fn get(&self, key: &str) -> Result<Option<String>, Error> {
        if let Some(value) = self.keys.get(key) {
            return Ok(Some(value.clone()));
        }

        let file_path = format!("{}/{}.bin", self.storage_path, key);
        if !Path::new(&file_path).exists() {
            return Ok(None);
        }

        let data = fs::read(file_path)?;
        let decoded: String = deserialize(&data).map_err(|e| Error::new(ErrorKind::Other, e))?;
        Ok(Some(decoded))
    }

    pub fn remove(&mut self, key: &str) -> Result<(), Error> {
        let file_path = format!("{}/{}.bin", self.storage_path, key);
        if Path::new(&file_path).exists() {
            fs::remove_file(file_path)?;
        }
        self.keys.remove(key);
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::tempdir;

    #[test]
    fn test_set_get() {
        let dir = tempdir().unwrap();
        let mut store = KvStore::new(dir.path().to_str().unwrap()).unwrap();
        
        store.set("key1".to_string(), "value1".to_string()).unwrap();
        assert_eq!(store.get("key1").unwrap(), Some("value1".to_string()));
    }

    #[test]
    fn test_get_non_existent() {
        let dir = tempdir().unwrap();
        let store = KvStore::new(dir.path().to_str().unwrap()).unwrap();
        
        assert_eq!(store.get("nonexistent").unwrap(), None);
    }

    #[test]
    fn test_remove() {
        let dir = tempdir().unwrap();
        let mut store = KvStore::new(dir.path().to_str().unwrap()).unwrap();
        
        store.set("key1".to_string(), "value1".to_string()).unwrap();
        store.remove("key1").unwrap();
        assert_eq!(store.get("key1").unwrap(), None);
    }

    #[test]
    fn test_persistence() {
        let dir = tempdir().unwrap();
        let path = dir.path().to_str().unwrap();
        
        {
            let mut store = KvStore::new(path).unwrap();
            store.set("key1".to_string(), "value1".to_string()).unwrap();
        }
        
        {
            let store = KvStore::new(path).unwrap();
            assert_eq!(store.get("key1").unwrap(), Some("value1".to_string()));
        }
    }

    #[test]
    fn test_overwrite() {
        let dir = tempdir().unwrap();
        let mut store = KvStore::new(dir.path().to_str().unwrap()).unwrap();
        
        store.set("key1".to_string(), "value1".to_string()).unwrap();
        store.set("key1".to_string(), "value2".to_string()).unwrap();
        assert_eq!(store.get("key1").unwrap(), Some("value2".to_string()));
    }
}