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
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
113
114
115
116

use std::io::Write;

use bson::{Bson, Document};

use crate::internal;

use super::{cache::set_cache, collection};

pub fn get_one_no_cache(
    db: &mut crate::Database,
    col: String,
    filter: Document,
) -> Result<Option<Document>, Box<dyn std::error::Error + Send + Sync>> {
    internal::ensure_folder(&db.path);

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

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

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

    for d in docs {
        if let Bson::Document(d) = d {
            if document_matches_filter(d, &filter) {
                return Ok(Some(d.clone()));
            }
        }
    }

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

pub fn get_one(
    db: &mut crate::Database,
    col: String,
    filter: Document,
) -> Result<Option<Document>, Box<dyn std::error::Error + Send + Sync>> {
    internal::ensure_folder(&db.path);

    if let Some(cache) = &*db.cache.lock().unwrap() {
        if let Some(doc) = cache.get(&format!("{}-{}", col, filter)) {
            return Ok(Some(doc.clone()));
        }
    }

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

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

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

    for d in docs {
        if let Bson::Document(d) = d {
            if document_matches_filter(d, &filter) {
                set_cache(db, col, filter, d);
                return Ok(Some(d.clone()));
            }
        }
    }

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

pub fn get_many(
    db: &mut crate::Database,
    col: String,
    filter: Document,
) -> Result<Vec<Document>, Box<dyn std::error::Error + Send + Sync>> {
    internal::ensure_folder(&db.path);

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

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

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

    let mut results = Vec::new();

    for d in docs {
        if let Bson::Document(d) = d {
            if document_matches_filter(d, &filter) {
                results.push(d.clone());
            }
        }
    }

    Ok(results)
}

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

    true
}