lora-wal 0.8.4

Write-ahead log and replay engine for LoraDB.
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193

use lora_store::{
    LoraBinary, LoraDate, LoraDateTime, LoraDuration, LoraLocalDateTime, LoraLocalTime, LoraPoint,
    LoraTime, LoraVector, MutationEvent, Properties, PropertyValue, VectorValues,
};

use super::decode::{decode_event, decode_events};
use super::encode::{encode_event, encode_events, encoded_event_len, encoded_events_len};
use crate::errors::WalError;

fn sample_event() -> MutationEvent {
    let mut props = Properties::new();
    props.insert("name".into(), PropertyValue::String("alice".into()));
    props.insert("age".into(), PropertyValue::Int(42));
    props.insert(
        "blob".into(),
        PropertyValue::Binary(LoraBinary::from_segments(vec![
            vec![0, 1, 2],
            vec![3, 4, 255],
        ])),
    );
    props.insert(
        "nested".into(),
        PropertyValue::List(vec![PropertyValue::Bool(true), PropertyValue::Null]),
    );
    MutationEvent::CreateNode {
        id: 7,
        labels: vec!["Person".into(), "Admin".into()],
        properties: props,
    }
}

fn all_extension_values_event() -> MutationEvent {
    let mut props = Properties::new();
    props.insert(
        "date".into(),
        PropertyValue::Date(LoraDate {
            year: 2026,
            month: 4,
            day: 27,
        }),
    );
    props.insert(
        "time".into(),
        PropertyValue::Time(LoraTime {
            hour: 12,
            minute: 34,
            second: 56,
            nanosecond: 789,
            offset_seconds: 3600,
        }),
    );
    props.insert(
        "localtime".into(),
        PropertyValue::LocalTime(LoraLocalTime {
            hour: 1,
            minute: 2,
            second: 3,
            nanosecond: 4,
        }),
    );
    props.insert(
        "datetime".into(),
        PropertyValue::DateTime(LoraDateTime {
            year: 2026,
            month: 4,
            day: 27,
            hour: 12,
            minute: 34,
            second: 56,
            nanosecond: 789,
            offset_seconds: -1800,
        }),
    );
    props.insert(
        "localdatetime".into(),
        PropertyValue::LocalDateTime(LoraLocalDateTime {
            year: 2026,
            month: 4,
            day: 27,
            hour: 12,
            minute: 34,
            second: 56,
            nanosecond: 789,
        }),
    );
    props.insert(
        "duration".into(),
        PropertyValue::Duration(LoraDuration {
            months: 14,
            days: 3,
            seconds: 4,
            nanoseconds: 5,
        }),
    );
    props.insert(
        "point".into(),
        PropertyValue::Point(LoraPoint {
            x: 4.9,
            y: 52.37,
            z: Some(7.0),
            srid: 4979,
        }),
    );
    props.insert(
        "vector_f64".into(),
        PropertyValue::Vector(LoraVector {
            dimension: 2,
            values: VectorValues::Float64(vec![1.5, 2.5]),
        }),
    );
    props.insert(
        "vector_f32".into(),
        PropertyValue::Vector(LoraVector {
            dimension: 2,
            values: VectorValues::Float32(vec![1.5, 2.5]),
        }),
    );
    props.insert(
        "vector_i64".into(),
        PropertyValue::Vector(LoraVector {
            dimension: 2,
            values: VectorValues::Integer64(vec![1, -2]),
        }),
    );
    props.insert(
        "vector_i32".into(),
        PropertyValue::Vector(LoraVector {
            dimension: 2,
            values: VectorValues::Integer32(vec![1, -2]),
        }),
    );
    props.insert(
        "vector_i16".into(),
        PropertyValue::Vector(LoraVector {
            dimension: 2,
            values: VectorValues::Integer16(vec![1, -2]),
        }),
    );
    props.insert(
        "vector_i8".into(),
        PropertyValue::Vector(LoraVector {
            dimension: 2,
            values: VectorValues::Integer8(vec![1, -2]),
        }),
    );
    MutationEvent::SetNodeProperty {
        node_id: 7,
        key: "extensions".into(),
        value: PropertyValue::Map(props),
    }
}

#[test]
fn event_round_trip() {
    let event = sample_event();
    let encoded = encode_event(&event).unwrap();
    assert_eq!(encoded_event_len(&event).unwrap(), encoded.len());
    assert_eq!(decode_event(&encoded).unwrap(), event);
}

#[test]
fn event_batch_round_trip() {
    let events = vec![sample_event(), MutationEvent::Clear];
    let encoded = encode_events(&events).unwrap();
    assert_eq!(encoded_events_len(&events).unwrap(), encoded.len());
    assert_eq!(decode_events(&encoded).unwrap(), events);
}

#[test]
fn non_compact_payload_is_rejected() {
    assert!(matches!(
        decode_event(b"not-lora-wal"),
        Err(WalError::Decode(_))
    ));
}

#[test]
fn add_label_round_trip() {
    let event = MutationEvent::AddNodeLabel {
        node_id: 99,
        label: "User".into(),
    };
    let encoded = encode_event(&event).unwrap();
    assert_eq!(decode_event(&encoded).unwrap(), event);
}

#[test]
fn all_extension_values_round_trip() {
    let event = all_extension_values_event();
    let encoded = encode_event(&event).unwrap();
    assert_eq!(encoded_event_len(&event).unwrap(), encoded.len());
    assert_eq!(decode_event(&encoded).unwrap(), event);
}