selene-db-core 1.3.0

Foundation types for the selene-db ISO/IEC 39075:2024 GQL property graph engine.
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

//! Compact stable discriminants for [`Change`] variants.

use crate::Change;

/// Stable discriminant for one [`Change`] variant.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(u8)]
pub enum ChangeKind {
    /// [`Change::NodeCreated`].
    NodeCreated = 0,
    /// [`Change::NodeUpdated`].
    NodeUpdated = 1,
    /// [`Change::NodeDeleted`].
    NodeDeleted = 2,
    /// [`Change::EdgeCreated`].
    EdgeCreated = 3,
    /// [`Change::EdgeUpdated`].
    EdgeUpdated = 4,
    /// [`Change::EdgeDeleted`].
    EdgeDeleted = 5,
    /// [`Change::SchemaChanged`].
    SchemaChanged = 6,
    /// [`Change::NodePropertyRemoved`].
    NodePropertyRemoved = 7,
    /// [`Change::EdgePropertyRemoved`].
    EdgePropertyRemoved = 8,
    /// [`Change::NodeLabelRemoved`].
    NodeLabelRemoved = 9,
    /// [`Change::NodesOfTypeTruncated`].
    NodesOfTypeTruncated = 10,
    /// [`Change::EdgesOfTypeTruncated`].
    EdgesOfTypeTruncated = 11,
    /// [`Change::GraphReset`].
    GraphReset = 12,
}

impl Change {
    /// Return the compact kind discriminant for this change.
    #[must_use]
    pub const fn kind(&self) -> ChangeKind {
        match self {
            Self::NodeCreated { .. } => ChangeKind::NodeCreated,
            Self::NodeUpdated { .. } => ChangeKind::NodeUpdated,
            Self::NodeDeleted { .. } => ChangeKind::NodeDeleted,
            Self::EdgeCreated { .. } => ChangeKind::EdgeCreated,
            Self::EdgeUpdated { .. } => ChangeKind::EdgeUpdated,
            Self::EdgeDeleted { .. } => ChangeKind::EdgeDeleted,
            Self::SchemaChanged { .. } => ChangeKind::SchemaChanged,
            Self::NodePropertyRemoved { .. } => ChangeKind::NodePropertyRemoved,
            Self::EdgePropertyRemoved { .. } => ChangeKind::EdgePropertyRemoved,
            Self::NodeLabelRemoved { .. } => ChangeKind::NodeLabelRemoved,
            Self::NodesOfTypeTruncated { .. } => ChangeKind::NodesOfTypeTruncated,
            Self::EdgesOfTypeTruncated { .. } => ChangeKind::EdgesOfTypeTruncated,
            Self::GraphReset {} => ChangeKind::GraphReset,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::ChangeKind;
    use crate::Change;

    #[test]
    fn change_kind_maps_every_change_variant() {
        let expected = [
            ChangeKind::NodeCreated,
            ChangeKind::NodeUpdated,
            ChangeKind::NodeDeleted,
            ChangeKind::EdgeCreated,
            ChangeKind::EdgeUpdated,
            ChangeKind::EdgeDeleted,
            ChangeKind::SchemaChanged,
            ChangeKind::NodePropertyRemoved,
            ChangeKind::EdgePropertyRemoved,
            ChangeKind::NodeLabelRemoved,
            ChangeKind::NodesOfTypeTruncated,
            ChangeKind::EdgesOfTypeTruncated,
            ChangeKind::GraphReset,
        ];
        assert_eq!(Change::VARIANT_COUNT, expected.len());

        for (factory, kind) in Change::ALL.iter().zip(expected) {
            assert_eq!(factory().kind(), kind);
        }
    }

    #[test]
    fn change_kind_discriminants_are_contiguous_and_stable() {
        // The discriminant values are a stable telemetry/ABI surface; pin them
        // so a reordering of the `ChangeKind` enum is caught at test time.
        assert_eq!(ChangeKind::NodeCreated as u8, 0);
        assert_eq!(ChangeKind::NodePropertyRemoved as u8, 7);
        assert_eq!(ChangeKind::GraphReset as u8, 12);
    }
}