nodedb 0.2.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
145
146
147
148
149
150
151
152
153
154
155
156
157

// SPDX-License-Identifier: BUSL-1.1

//! Recursive clone correctness: `CLONE DATABASE clone_of_clone FROM clone`.
//!
//! A clone-of-a-clone must read rows that originate in the original source,
//! and writes in the grandchild clone must not affect either its parent clone
//! or the original source.

mod common;

use common::pgwire_harness::TestServer;

fn first_value(msgs: &[tokio_postgres::SimpleQueryMessage]) -> Option<String> {
    for msg in msgs {
        if let tokio_postgres::SimpleQueryMessage::Row(row) = msg {
            return row.get(0).map(|s| s.to_owned());
        }
    }
    None
}

/// Grandchild clone must read through two indirection levels and reach the
/// original source row.
#[tokio::test]
async fn grandchild_clone_reads_original_row() {
    let server = TestServer::start().await;
    let client = &*server.client;

    // Original source.
    client
        .simple_query("CREATE DATABASE rec_origin")
        .await
        .expect("CREATE DATABASE rec_origin");
    client
        .simple_query("USE DATABASE rec_origin")
        .await
        .expect("USE rec_origin");
    client
        .simple_query("CREATE COLLECTION items (k STRING PRIMARY KEY, v STRING) WITH (engine='kv')")
        .await
        .expect("CREATE COLLECTION items");
    client
        .simple_query("INSERT INTO items (k, v) VALUES ('root', 'origin-value')")
        .await
        .expect("INSERT root");

    // First-level clone.
    client
        .simple_query("USE DATABASE default")
        .await
        .expect("USE default");
    client
        .simple_query("CLONE DATABASE rec_clone1 FROM rec_origin")
        .await
        .expect("CLONE rec_clone1");

    // Second-level clone (clone of clone).
    client
        .simple_query("CLONE DATABASE rec_clone2 FROM rec_clone1")
        .await
        .expect("CLONE rec_clone2");

    // Grandchild must read the origin row.
    client
        .simple_query("USE DATABASE rec_clone2")
        .await
        .expect("USE rec_clone2");
    let msgs = client
        .simple_query("SELECT v FROM items WHERE k = 'root'")
        .await
        .expect("SELECT from grandchild");
    assert_eq!(
        first_value(&msgs).as_deref(),
        Some("origin-value"),
        "grandchild clone must read the original source row"
    );
}

/// A write to the grandchild must NOT be visible in the parent clone or the
/// origin.
#[tokio::test]
async fn write_in_grandchild_does_not_affect_parent_or_origin() {
    let server = TestServer::start().await;
    let client = &*server.client;

    // Origin.
    client
        .simple_query("CREATE DATABASE rec2_origin")
        .await
        .expect("CREATE DATABASE rec2_origin");
    client
        .simple_query("USE DATABASE rec2_origin")
        .await
        .expect("USE rec2_origin");
    client
        .simple_query("CREATE COLLECTION data (k STRING PRIMARY KEY, v STRING) WITH (engine='kv')")
        .await
        .expect("CREATE COLLECTION data");
    client
        .simple_query("INSERT INTO data (k, v) VALUES ('shared', 'unchanged')")
        .await
        .expect("INSERT shared");

    // Clone chain.
    client
        .simple_query("USE DATABASE default")
        .await
        .expect("USE default");
    client
        .simple_query("CLONE DATABASE rec2_clone1 FROM rec2_origin")
        .await
        .expect("CLONE rec2_clone1");
    client
        .simple_query("CLONE DATABASE rec2_clone2 FROM rec2_clone1")
        .await
        .expect("CLONE rec2_clone2");

    // Overwrite in grandchild.
    client
        .simple_query("USE DATABASE rec2_clone2")
        .await
        .expect("USE rec2_clone2");
    client
        .simple_query("UPDATE data SET v = 'modified' WHERE k = 'shared'")
        .await
        .expect("UPDATE in grandchild");

    // Parent clone still sees original value.
    client
        .simple_query("USE DATABASE rec2_clone1")
        .await
        .expect("USE rec2_clone1");
    let parent_msgs = client
        .simple_query("SELECT v FROM data WHERE k = 'shared'")
        .await
        .expect("SELECT from parent clone");
    assert_eq!(
        first_value(&parent_msgs).as_deref(),
        Some("unchanged"),
        "parent clone must not see grandchild write"
    );

    // Origin still sees original value.
    client
        .simple_query("USE DATABASE rec2_origin")
        .await
        .expect("USE rec2_origin");
    let origin_msgs = client
        .simple_query("SELECT v FROM data WHERE k = 'shared'")
        .await
        .expect("SELECT from origin");
    assert_eq!(
        first_value(&origin_msgs).as_deref(),
        Some("unchanged"),
        "origin must not see grandchild write"
    );
}