nodedb 0.4.0

Local-first, real-time, edge-to-cloud hybrid database for multi-modal workloads
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

// SPDX-License-Identifier: BUSL-1.1

//! Classify the columnar-storage-family engine ops (`ColumnarOp`,
//! `TimeseriesOp`, `TextOp`, `SpatialOp`) into an optional `ReplicatedWrite`.
//!
//! Each function is exhaustive over its op enum (not a catch-all): a new
//! variant is a compile error here, so no future write in these families is
//! silently left un-replicated.

#![deny(clippy::wildcard_enum_match_arm)]

use super::super::types::ReplicatedWrite;
use super::{columnar, entry::encode_provenance};
use nodedb_physical::physical_plan::{ColumnarOp, SpatialOp, TextOp, TimeseriesOp};

/// Encode a `ColumnarOp` write variant into its `ReplicatedWrite` wire shape,
/// or `None` for scans.
pub(super) fn columnar_write(op: &ColumnarOp) -> Option<ReplicatedWrite> {
    Some(match op {
        ColumnarOp::Insert {
            collection,
            payload,
            surrogates,
            schema_bytes,
            provenance,
            // wal_lsn is omitted from the wire envelope; followers allocate
            // their own LSN at apply time. intent and on_conflict_updates are
            // always Insert/empty on the sync path and are hardcoded on decode.
            ..
        } => columnar::columnar_ingest(
            collection,
            payload,
            surrogates,
            schema_bytes,
            encode_provenance(provenance),
        ),
        ColumnarOp::Delete {
            collection,
            filters,
        } => columnar::bulk_delete(collection, filters),
        ColumnarOp::Update {
            collection,
            filters,
            updates,
        } => columnar::bulk_update(collection, filters, updates),

        // Not a write — reads / scans.
        ColumnarOp::Scan { .. } | ColumnarOp::MaterializeScan { .. } => return None,
    })
}

/// Encode a `TimeseriesOp` write variant into its `ReplicatedWrite` wire
/// shape, or `None` for scans.
pub(super) fn timeseries_write(op: &TimeseriesOp) -> Option<ReplicatedWrite> {
    Some(match op {
        TimeseriesOp::Ingest {
            collection,
            payload,
            format,
            surrogates,
            provenance,
            ..
        } => columnar::timeseries_ingest(
            collection,
            payload,
            format,
            surrogates,
            encode_provenance(provenance),
        ),

        // Not a write — reads / scans.
        TimeseriesOp::Scan { .. } => return None,
    })
}

/// Encode a `TextOp` write variant into its `ReplicatedWrite` wire shape, or
/// `None` for the search / DDL-config variants.
pub(super) fn text_write(op: &TextOp) -> Option<ReplicatedWrite> {
    Some(match op {
        TextOp::FtsIndexDoc {
            collection,
            surrogate,
            text,
            provenance,
        } => columnar::fts_index(
            collection,
            surrogate.as_u32(),
            text,
            encode_provenance(provenance),
        ),
        TextOp::FtsDeleteDoc {
            collection,
            surrogate,
            provenance,
        } => columnar::fts_delete(
            collection,
            surrogate.as_u32(),
            encode_provenance(provenance),
        ),

        // Not a write — BM25 / phrase / hybrid searches and the config-only
        // analyzer binding (single-node, non-WAL-durable).
        TextOp::Search { .. }
        | TextOp::BM25ScoreScan { .. }
        | TextOp::PhraseSearch { .. }
        | TextOp::HybridSearch { .. }
        | TextOp::HybridSearchTriple { .. }
        | TextOp::SetAnalyzer { .. } => return None,
    })
}

/// Encode a `SpatialOp` write variant into its `ReplicatedWrite` wire shape,
/// or `None` for scans.
pub(super) fn spatial_write(op: &SpatialOp) -> Option<ReplicatedWrite> {
    Some(match op {
        SpatialOp::Insert {
            collection,
            field,
            surrogate,
            geometry,
            provenance,
        } => columnar::spatial_insert(
            collection,
            field,
            surrogate.as_u32(),
            geometry,
            encode_provenance(provenance),
        ),
        SpatialOp::Delete {
            collection,
            field,
            surrogate,
            provenance,
        } => columnar::spatial_delete(
            collection,
            field,
            surrogate.as_u32(),
            encode_provenance(provenance),
        ),

        // Not a write — R-tree index scan.
        SpatialOp::Scan { .. } => return None,
    })
}