reindeer 0.3.0

A small entity-based embedded database with a minimal no-SQL relationnal model, written in pure 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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::error::Result;
use crate::AutoIncrementEntity;
use serde_derive::{Deserialize, Serialize};
use sled::Db;

use crate::DeletionBehaviour;
use crate::Entity;

#[derive(Serialize, Deserialize,Entity)]
#[entity(name = "entity_1",version = 1,crate = "crate")]
#[siblings(("entity_3",Cascade))]
pub struct Entity1 {
    pub id: u32,
    pub prop1: String,
}

#[derive(Serialize, Deserialize, Clone,Entity)]
#[entity(name = "entity_2",version = 1,crate = "crate")]
#[children(("child_entity_1",Cascade))]
pub struct Entity2 {
    pub id: String,
    pub prop2: u32,
}

#[derive(Serialize, Deserialize,Entity)]
#[entity(name = "entity_3",version = 1,crate = "crate")]
#[siblings(("entity_1",Error))]
#[children(("child_entity_2",Error))]
pub struct Entity3 {
    pub id: u32,
}

#[derive(Serialize, Deserialize, Clone,Entity)]
#[entity(name = "child_entity_1",version = 1,crate = "crate")]
#[children(("grand_child_entity",Cascade))]
pub struct ChildEntity1 {
    id: (String, u32),
}

#[derive(Serialize, Deserialize,Entity)]
#[entity(name = "child_entity_2",version = 1,crate = "crate")]
pub struct ChildEntity2 {
    id: (u32, u32),
}

#[derive(Serialize, Deserialize,Entity)]
#[entity(name = "grand_child_entity",version = 1,crate = "crate")]
pub struct GrandChildEntity {
    id: ((String, u32), u32),
}

pub fn set_up(name: &str) -> Result<Db> {
    let mut dir = std::env::temp_dir();
    dir.push(name);

    let db = crate::open(dir.to_str().unwrap())?;
    Entity1::register(&db)?;
    Entity2::register(&db)?;
    Entity3::register(&db)?;
    ChildEntity1::register(&db)?;
    ChildEntity2::register(&db)?;
    GrandChildEntity::register(&db)?;
    Ok(db)
}

pub fn set_up_content(db: &Db) -> Result<()> {
    let mut e1 = Entity1 {
        id: 0,
        prop1: String::from("Hello, World!"),
    };
    e1.save_next(db)?;
    e1.prop1 = String::from("Hello, Nancy!");
    e1.save_next(db)?;
    e1.prop1 = String::from("Hello, Jack!");
    e1.save_next(db)?;
    let mut e2 = Entity2 {
        id: String::from("id1"),
        prop2: 3,
    };
    e2.save(db)?;
    e2.set_key(&String::from("id2"));
    e2.prop2 = 5;
    e2.save(db)?;
    let e2_2 = e2.clone();
    e2.set_key(&String::from("id3"));
    e2.prop2 = 1000;
    e2.save(db)?;
    let mut e3 = Entity3 { id: 0 };
    e3.save_next(db)?;
    e3.save_next(db)?;
    let mut e4 = ChildEntity1 {
        id: (String::from("id0"), 0),
    };
    e3.save_next(db)?;

    e2.save_next_child(&mut e4, db)?;
    e2.save_next_child(&mut e4, db)?;
    e2.save_next_child(&mut e4, db)?;
    let mut e4_2 = e4.clone();
    e2_2.save_next_child(&mut e4_2, db)?;

    let mut e5 = ChildEntity2 { id: (0, 0) };
    e3.save_next_child(&mut e5, db)?;
    e3.save_next_child(&mut e5, db)?;
    e4.create_relation(
        &e5,
        DeletionBehaviour::BreakLink,
        DeletionBehaviour::BreakLink,
        None,
        db,
    )?;
    e3.save_next_child(&mut e5, db)?;
    let mut grand_child = GrandChildEntity {
        id: ((String::from("id0"), 1), 0),
    };
    e4.save_next_child(&mut grand_child, db)?;
    e4.save_next_child(&mut grand_child, db)?;
    e4.save_next_child(&mut grand_child, db)?;
    assert_eq!(grand_child.get_key().0 .0, "id3");
    assert_eq!(grand_child.get_key().0 .1, 2);
    assert_eq!(grand_child.get_key().1, 2);
    Ok(())
}

pub fn tear_down(name: &str) -> Result<()> {
    let mut dir = std::env::temp_dir();
    dir.push(name);
    std::fs::remove_dir_all(dir.to_str().unwrap())?;
    Ok(())
}