gddb 0.3.1

GDDB is a superfast in-memory database designed for use in Godot.
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

use crate::prelude::*;

/// The primary Godot interface to the database.
#[derive(NativeClass)]
#[inherit(Node)]
pub struct GDDB {
    storage: Database<Record>,
}

#[methods]
impl GDDB {
    fn new(_owner: &Node) -> Self {
        let db: Database<Record> = Database::new("GAME", None, false);
        Self { storage: db }
    }

    // Creates a database record
    #[export]
    pub fn create(&mut self, _owner: &Node, model: String, attributes: Dictionary) -> String {
        let mut record = Record::new(model);
        let uuid = record.uuid.clone();
        record.attributes = attributes.to_json().to_string();

        self.storage.create(record).unwrap();

        uuid
    }

    // Finds a database record given a uuid
    #[export]
    pub fn find(&mut self, _owner: &Node, uuid: String) -> GodotString {
        let record = self
            .storage
            .find(|f| &f.uuid, uuid)
            .expect("Could not find record");

        let data = Dictionary::new();

        data.insert("uuid", record.uuid.clone());
        data.insert("model", record.model.clone());
        data.insert("attributes", record.attributes.clone());

        data.to_json()
    }

    // Updates a record
    #[export]
    pub fn update(&mut self, _owner: &Node, uuid: String, model: String, attributes: String) {
        let new = Record {
            uuid,
            model,
            attributes,
        };

        let uuid = new.uuid.clone();
        let original = self
            .storage
            .find(|f| &f.uuid, uuid)
            .expect("Could not find record to update")
            .clone();

        self.storage
            .update(&original, new.clone())
            .expect("Cannot update record");
    }

    // Removes a record
    #[export]
    pub fn destroy(&mut self, _owner: &Node, uuid: String, model: String, attributes: String) {
        let record = Record {
            uuid,
            model,
            attributes,
        };

        self.storage.destroy(&record).expect("Cannot remove record");
    }
}