start 0.4.4

StartDB – Embedded NoSQL Database in Rust
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

use bson::{doc, Bson, Document};
use serde::{de::DeserializeOwned, Serialize};

use crate::{db::{self, catalog::session::Session, query::filtering::Filter}, HandleResult};

pub struct FindQuery<'a> {
    session: &'a Session,
    filter: Option<Filter>,
    skip: Option<u64>,
    limit: Option<u64>,
}

impl <'a>FindQuery<'a> {
    pub fn filter(mut self, filter: Filter) -> Self {
        self.filter = Some(filter);
        self
    }

    pub fn skip(mut self, skip: u64) -> Self {
        self.skip = Some(skip);
        self
    }

    pub fn limit(mut self, limit: u64) -> Self {
        self.limit = Some(limit);
        self
    }

    pub fn from<T>(mut self, collection: &str)-> HandleResult<Vec<T>>
    where T: DeserializeOwned {
        let raw_results = db::commands::find::find(
            self.session,
            collection,
            self.filter.take(), 
            self.skip,
            self.limit)?;

        // Convert Vec<Bson> or Vec<Document> to Vec<T>
        let mut results = Vec::new();
        for entry in raw_results {
            let doc = match entry {
                Bson::Document(d) => d,
                _ => return Err("Expected Bson::Document".into()),
            };

            let deserialized: T = bson::from_document(doc)?;
            results.push(deserialized);
        }

        Ok(results)
    }
}

pub struct DeleteQuery<'a> {
    session: &'a Session,
    filter: Option<Filter>,
}

impl <'a>DeleteQuery<'a> {
    pub fn filter(mut self, filter: Filter) -> Self {
        self.filter = Some(filter);
        self
    }

    pub fn from(mut self, collection: &str) -> HandleResult<()> {
        db::commands::delete::delete(self.session, collection, self.filter.take())
    }
}

pub struct UpdateQuery<'a> {
    session: &'a Session,
    filter: Option<Filter>,
    update_document: Document,
}

impl <'a>UpdateQuery<'a> {
    pub fn filter(mut self, filter: Filter) -> Self {
        self.filter = Some(filter);
        self
    }

    pub fn set(mut self, document: Document) -> Self {
        self.update_document.insert("$set", document);
        self
    }

    pub fn from(mut self, collection: &str) -> HandleResult<()> {
        db::commands::update::update(
            self.session,
            self.filter.take(),
            self.update_document,
            collection,
        )
    }
}

impl Session {
    pub fn insert<T>(&self, collection: &str, document: T) -> HandleResult<()>
    where T: Serialize {
        db::commands::insert::insert(self, collection, bson::to_bson(&document)?)?;
        Ok(())
    }

    pub fn delete(&self) -> DeleteQuery {
        DeleteQuery { session: self, filter: None }
    }

    pub fn find(&self) -> FindQuery {
        FindQuery { session: self, filter: None, skip: None, limit: None }
    }

    pub fn update(&self) -> UpdateQuery {
        UpdateQuery { session: self, filter: None, update_document: Document::new() }
    }
}