cached_db 0.2.2

A NoSQL database with a built in cache layer.
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

use std::io::Write;

use bson::{Bson, Document};

use crate::internal;

use super::collection;

pub fn update_one(
    path: &String,
    col: String,
    filter: Document,
    update: Document,
) -> Result<Option<Document>, Box<dyn std::error::Error + Send + Sync>> {
    internal::ensure_folder(path);

    let data = collection::get(path, col.clone());

    let mut doc = match data {
        Ok(doc) => doc,
        Err(_) => Document::new(),
    };

    let docs = match doc.get(&col) {
        Some(Bson::Array(docs)) => docs.clone(),
        _ => return Err("Collection not found".into()),
    };

    for (index, d) in docs.iter().enumerate() {
        if let Bson::Document(d) = d {
            if document_matches_filter(d, &filter) {
                let mut new_data = d.clone();

                for (key, value) in &update {
                    new_data.insert(key, value);
                }

                let mut new_docs = docs.clone();
                new_docs[index] = Bson::Document(new_data.clone());

                doc.insert(&col, new_docs);

                let mut file = std::fs::File::create(format!("{}/{}.bson", path, &col))?;
                file.write_all(bson::to_vec(&doc)?.as_slice())?;

                return Ok(Some(new_data));
            }
        }
    }

    Err("Not found".into())
}

fn document_matches_filter(doc: &Document, filter: &Document) -> bool {
    for (key, value) in filter {
        if doc.get(key) != Some(value) {
            return false;
        }
    }

    true
}