nodedb 0.3.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

// SPDX-License-Identifier: BUSL-1.1

//! Graph DSL commands: GRAPH INSERT EDGE, GRAPH DELETE EDGE,
//! GRAPH LABEL/UNLABEL, GRAPH TRAVERSE, GRAPH NEIGHBORS, GRAPH PATH,
//! GRAPH ALGO.
//!
//! Every handler consumes already-parsed typed fields from
//! `nodedb_sql::ddl_ast::NodedbStatement`. Raw-SQL tokenising lives
//! in `nodedb-sql::ddl_ast::graph_parse` — no handler in this
//! directory does string-prefix parsing.

mod algo;
mod edge;
pub(super) mod rag_fusion;
mod response;
mod stats;
mod traverse;

use pgwire::api::results::Response;
use pgwire::error::PgWireResult;

use nodedb_sql::ddl_ast::statement::{GraphStmt, NodedbStatement};

use crate::control::security::identity::AuthenticatedIdentity;
use crate::control::state::SharedState;

/// Dispatch a parsed graph-DSL variant to its handler.
///
/// Returns `None` when the statement is not a graph DSL variant,
/// so the caller can fall through to other dispatchers.
pub async fn dispatch_typed(
    state: &SharedState,
    identity: &AuthenticatedIdentity,
    stmt: NodedbStatement,
) -> Option<PgWireResult<Vec<Response>>> {
    match stmt {
        NodedbStatement::Graph(GraphStmt::GraphInsertEdge {
            collection,
            src,
            dst,
            label,
            properties,
        }) => {
            Some(edge::insert_edge(state, identity, collection, src, dst, label, properties).await)
        }
        NodedbStatement::Graph(GraphStmt::GraphDeleteEdge {
            collection,
            src,
            dst,
            label,
        }) => Some(edge::delete_edge(state, identity, collection, src, dst, label).await),
        NodedbStatement::Graph(GraphStmt::GraphSetLabels {
            node_id,
            labels,
            remove,
        }) => Some(edge::set_node_labels(state, identity, node_id, labels, remove).await),
        NodedbStatement::Graph(GraphStmt::GraphTraverse {
            start,
            depth,
            edge_label,
            direction,
        }) => Some(traverse::traverse(state, identity, start, depth, edge_label, direction).await),
        NodedbStatement::Graph(GraphStmt::GraphNeighbors {
            node,
            edge_label,
            direction,
        }) => Some(traverse::neighbors(state, identity, node, edge_label, direction).await),
        NodedbStatement::Graph(GraphStmt::GraphPath {
            src,
            dst,
            max_depth,
            edge_label,
        }) => Some(traverse::shortest_path(state, identity, src, dst, max_depth, edge_label).await),
        NodedbStatement::Graph(GraphStmt::GraphAlgo {
            algorithm,
            collection,
            edge_label,
            damping,
            tolerance,
            resolution,
            max_iterations,
            sample_size,
            source_node,
            direction,
            mode,
            personalization,
        }) => Some(
            algo::algo(
                state,
                identity,
                &algorithm,
                collection,
                edge_label,
                damping,
                tolerance,
                resolution,
                max_iterations,
                sample_size,
                source_node,
                direction,
                mode,
                personalization,
            )
            .await,
        ),
        NodedbStatement::Graph(GraphStmt::GraphRagFusion { collection, params }) => {
            Some(rag_fusion::rag_fusion(state, identity, collection, params).await)
        }
        NodedbStatement::Graph(GraphStmt::ShowGraphStats {
            collection,
            verbose,
            as_of,
        }) => Some(stats::show_graph_stats(state, identity, collection, verbose, as_of).await),
        // Non-graph NodedbStatement variants (CreateCollection, DropCollection,
        // etc.) return None so the caller can route them to the correct handler.
        _ => None,
    }
}