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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

// SPDX-License-Identifier: BUSL-1.1

//! `SHOW DATABASE LINEAGE FOR <name>` test.
//!
//! Creates a 3-deep clone chain (A → B → C) and verifies that
//! `SHOW DATABASE LINEAGE FOR C` returns rows for C, B, and A in
//! ancestor order.

mod common;

use common::pgwire_harness::TestServer;

/// A 3-deep clone chain A→B→C: `SHOW DATABASE LINEAGE FOR C` must return
/// at least 3 rows (C itself, B, A) in order from newest to oldest.
#[tokio::test]
async fn show_lineage_three_deep_chain() {
    let server = TestServer::start().await;
    let client = &*server.client;

    // ── A: root database ──────────────────────────────────────────────────────
    client
        .simple_query("CREATE DATABASE lineage_a")
        .await
        .expect("CREATE DATABASE lineage_a");
    client
        .simple_query("USE DATABASE lineage_a")
        .await
        .expect("USE lineage_a");
    client
        .simple_query(
            "CREATE COLLECTION nodes (id STRING PRIMARY KEY, label STRING) WITH (engine='kv')",
        )
        .await
        .expect("CREATE COLLECTION nodes");
    client
        .simple_query("INSERT INTO nodes (id, label) VALUES ('n1', 'root')")
        .await
        .expect("INSERT n1");

    // ── B: clone of A ─────────────────────────────────────────────────────────
    client
        .simple_query("USE DATABASE default")
        .await
        .expect("USE default");
    client
        .simple_query("CLONE DATABASE lineage_b FROM lineage_a")
        .await
        .expect("CLONE lineage_b FROM lineage_a");

    // ── C: clone of B ─────────────────────────────────────────────────────────
    client
        .simple_query("CLONE DATABASE lineage_c FROM lineage_b")
        .await
        .expect("CLONE lineage_c FROM lineage_b");

    // ── SHOW DATABASE LINEAGE FOR C ───────────────────────────────────────────
    let rows = client
        .simple_query("SHOW DATABASE LINEAGE FOR lineage_c")
        .await
        .expect("SHOW DATABASE LINEAGE FOR lineage_c");

    let data_rows: Vec<String> = rows
        .iter()
        .filter_map(|m| {
            if let tokio_postgres::SimpleQueryMessage::Row(r) = m {
                Some(r.get("name").unwrap_or("").to_string())
            } else {
                None
            }
        })
        .collect();

    // Must contain lineage_c, lineage_b, and lineage_a.
    assert!(
        data_rows.contains(&"lineage_c".to_string()),
        "lineage_c missing from lineage output: {data_rows:?}"
    );
    assert!(
        data_rows.contains(&"lineage_b".to_string()),
        "lineage_b missing from lineage output: {data_rows:?}"
    );
    assert!(
        data_rows.contains(&"lineage_a".to_string()),
        "lineage_a missing from lineage output: {data_rows:?}"
    );

    // First row must be lineage_c (the queried database itself).
    assert_eq!(
        data_rows.first().map(String::as_str),
        Some("lineage_c"),
        "first row must be the queried database (lineage_c), got: {data_rows:?}"
    );

    // Last row must be lineage_a (the root).
    assert_eq!(
        data_rows.last().map(String::as_str),
        Some("lineage_a"),
        "last row must be the root (lineage_a), got: {data_rows:?}"
    );
}

/// A non-cloned (root) database returns exactly one row for itself.
#[tokio::test]
async fn show_lineage_root_database_returns_one_row() {
    let server = TestServer::start().await;
    let client = &*server.client;

    client
        .simple_query("CREATE DATABASE lineage_root_only")
        .await
        .expect("CREATE DATABASE lineage_root_only");

    let rows = client
        .simple_query("SHOW DATABASE LINEAGE FOR lineage_root_only")
        .await
        .expect("SHOW DATABASE LINEAGE FOR lineage_root_only");

    let data_rows: Vec<String> = rows
        .iter()
        .filter_map(|m| {
            if let tokio_postgres::SimpleQueryMessage::Row(r) = m {
                Some(r.get("name").unwrap_or("").to_string())
            } else {
                None
            }
        })
        .collect();

    assert_eq!(
        data_rows.len(),
        1,
        "root-only database must return exactly 1 row, got: {data_rows:?}"
    );
    assert_eq!(data_rows[0], "lineage_root_only");
}