noatun 0.1.3

Noatun is an in-process, distributed database with materialized view support.
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use crate::data_types::NoatunHashMap;
use crate::database::{DatabaseSettings, OpenMode};
use crate::{Database, Message, NoatunTime, Object, OpaqueNoatunCell};
use crate::{MessageId, SavefileMessageSerializer};
use savefile_derive::Savefile;
use std::pin::Pin;

noatun_object!(
    struct MapDoc {
        object items: NoatunHashMap<u32, OpaqueNoatunCell<u32>>,
    }
);

#[derive(Savefile, Debug)]
pub struct MapMessage {
    index: usize,
    val: u32,
    reset: bool,
    destroy: bool,
}

impl Message for MapMessage {
    type Root = MapDoc;
    type Serializer = SavefileMessageSerializer<Self>;

    fn apply(&self, _time: MessageId, root: Pin<&mut Self::Root>) {
        let root = root.pin_project();
        if self.destroy {
            root.items.destroy();
        } else if self.reset {
            root.items.clear();
        } else {
            let value = root.items.get_insert(&(self.index as u32));
            value.set(self.val);
        }
    }
}

#[test]
fn test_map_local1() {
    super::setup_tracing();
    let mut db: Database<MapMessage> = Database::create_new(
        "test/test_map_subsumption1",
        OpenMode::Overwrite,
        DatabaseSettings::default(),
    )
    .unwrap();
    let mut db = db.begin_session_mut().unwrap();
    db.disable_filesystem_sync().unwrap();
    db.append_local(MapMessage {
        index: 42,
        val: 43,
        reset: false,
        destroy: false,
    })
    .unwrap();
    db.compact().unwrap();
    assert_eq!(db.count_messages(), 1);
    db.append_local(MapMessage {
        index: 0,
        val: 0,
        reset: true,
        destroy: false,
    })
    .unwrap();

    assert_eq!(
        db.count_messages(),
        1,
        "1 remains, since tombstones can't be pruned until cutoff"
    );
}

#[test]
fn test_map2() {
    super::setup_tracing();
    let mut db: Database<MapMessage> = Database::create_new(
        "test/test_map_subsumption2",
        OpenMode::Overwrite,
        DatabaseSettings::default(),
    )
    .unwrap();
    let mut db = db.begin_session_mut().unwrap();
    db.disable_filesystem_sync().unwrap();
    let msg1 = db
        .append_local(MapMessage {
            index: 42,
            val: 43,
            reset: false,
            destroy: false,
        })
        .unwrap();
    db.mark_transmitted(msg1.id).unwrap();

    assert_eq!(db.count_messages(), 1);
    db.append_local(MapMessage {
        index: 0,
        val: 0,
        reset: true,
        destroy: false,
    })
    .unwrap();

    assert_eq!(
        db.count_messages(),
        1,
        "all but the last message are subsumed, because local"
    );
}
#[test]
fn test_map3() {
    super::setup_tracing();
    let mut db: Database<MapMessage> = Database::create_new(
        "test/test_map_subsumption3",
        OpenMode::Overwrite,
        DatabaseSettings {
            mock_time: Some(NoatunTime::debug_time(0)),
            ..DatabaseSettings::default()
        },
    )
    .unwrap();
    let mut db = db.begin_session_mut().unwrap();
    db.disable_filesystem_sync().unwrap();
    let msg1 = db
        .append_local(MapMessage {
            index: 42,
            val: 43,
            reset: false,
            destroy: false,
        })
        .unwrap();
    db.mark_transmitted(msg1.id).unwrap();

    assert_eq!(db.count_messages(), 1);
    db.append_local(MapMessage {
        index: 0,
        val: 0,
        reset: true,
        destroy: false,
    })
    .unwrap();

    db.set_mock_time(NoatunTime::debug_time(1440)).unwrap();

    assert_eq!(
        db.count_messages(),
        1,
        "the reset-message is present in the clear-marker for the map"
    );

    db.append_local(MapMessage {
        index: 0,
        val: 0,
        reset: false,
        destroy: true,
    })
    .unwrap();

    db.set_mock_time(NoatunTime::debug_time(2 * 1440)).unwrap();

    assert_eq!(
        db.count_messages(),
        0,
        "Destroying the map should erase the clear-marker too"
    );
}