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

// SPDX-License-Identifier: BUSL-1.1

//! Encode `PhysicalPlan::Graph` variants into `ReplicatedWrite`.

use super::super::types::{ReplicatedBatchEdge, ReplicatedWrite};
use nodedb_physical::physical_plan::BatchEdge;

pub(super) fn edge_put(
    collection: &str,
    src_id: &str,
    label: &str,
    dst_id: &str,
    properties: &[u8],
    src_surrogate: u32,
    dst_surrogate: u32,
) -> ReplicatedWrite {
    ReplicatedWrite::EdgePut {
        collection: collection.to_owned(),
        src_id: src_id.to_owned(),
        label: label.to_owned(),
        dst_id: dst_id.to_owned(),
        properties: properties.to_vec(),
        src_surrogate,
        dst_surrogate,
    }
}

pub(super) fn edge_delete(
    collection: &str,
    src_id: &str,
    label: &str,
    dst_id: &str,
    src_surrogate: u32,
    dst_surrogate: u32,
) -> ReplicatedWrite {
    ReplicatedWrite::EdgeDelete {
        collection: collection.to_owned(),
        src_id: src_id.to_owned(),
        label: label.to_owned(),
        dst_id: dst_id.to_owned(),
        src_surrogate,
        dst_surrogate,
    }
}

pub(super) fn set_node_labels(node_id: &str, labels: &[String]) -> ReplicatedWrite {
    ReplicatedWrite::SetNodeLabels {
        node_id: node_id.to_owned(),
        labels: labels.to_vec(),
    }
}

pub(super) fn remove_node_labels(node_id: &str, labels: &[String]) -> ReplicatedWrite {
    ReplicatedWrite::RemoveNodeLabels {
        node_id: node_id.to_owned(),
        labels: labels.to_vec(),
    }
}

fn to_replicated_batch_edges(edges: &[BatchEdge]) -> Vec<ReplicatedBatchEdge> {
    edges
        .iter()
        .map(|e| ReplicatedBatchEdge {
            collection: e.collection.clone(),
            src_id: e.src_id.clone(),
            label: e.label.clone(),
            dst_id: e.dst_id.clone(),
            src_surrogate: e.src_surrogate.as_u32(),
            dst_surrogate: e.dst_surrogate.as_u32(),
        })
        .collect()
}

pub(super) fn edge_put_batch(edges: &[BatchEdge]) -> ReplicatedWrite {
    ReplicatedWrite::EdgePutBatch {
        edges: to_replicated_batch_edges(edges),
    }
}

pub(super) fn edge_delete_batch(edges: &[BatchEdge]) -> ReplicatedWrite {
    ReplicatedWrite::EdgeDeleteBatch {
        edges: to_replicated_batch_edges(edges),
    }
}