salamander-db 0.1.1

Embedded event-sourcing engine with instant recovery — the append-only log is the only durable structure.
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

//! `KvProjection`: a `BTreeMap<String, Vec<u8>>` folded over `Put`/`Delete`
//! events. The engine-correctness workhorse; used by the crash harness.
//!
//! Kept in the `agent` module for now (Phase 1.5 spec, WP-1 step 4): its
//! `Put`/`Delete` live in `EventBody`, so it folds `EventBody` like the
//! session view does. The query layer's `IndexedView` (WP-3) supersedes it
//! as the general-purpose, payload-agnostic store.

use std::collections::BTreeMap;

use super::EventBody;
use crate::event::Event;
use crate::projection::Projection;

/// A last-write-wins key/value store folded from [`EventBody::Put`] and
/// [`EventBody::Delete`] events. The simplest built-in projection; the
/// query layer's [`crate::IndexedView`] is the general-purpose store.
#[derive(Debug, Default)]
pub struct KvProjection {
    state: BTreeMap<String, Vec<u8>>,
    cursor: u64,
}

impl Projection for KvProjection {
    type Body = EventBody;
    type State = BTreeMap<String, Vec<u8>>;

    fn apply(&mut self, event: &Event<EventBody>) {
        match &event.body {
            EventBody::Put { key, value } => {
                self.state.insert(key.clone(), value.clone());
            }
            EventBody::Delete { key } => {
                self.state.remove(key);
            }
            _ => {}
        }
        self.cursor = event.offset + 1;
    }

    fn cursor(&self) -> u64 {
        self.cursor
    }

    fn state(&self) -> &Self::State {
        &self.state
    }
}