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

// SPDX-License-Identifier: BUSL-1.1

//! Regression coverage for C1/#156: a table-qualified WHERE column
//! (`u.name` / `users.name`) on a single-table query must not silently
//! match zero rows. Before the fix the qualifier was retained into the
//! scan filter's field name (`"u.name"`), which no stored document ever
//! has, so every row was silently filtered out with no error.

mod common;

use common::pgwire_harness::TestServer;

async fn seed(server: &TestServer) {
    server
        .exec(
            "CREATE COLLECTION t (\
                id STRING PRIMARY KEY, \
                name STRING, \
                age INT) WITH (engine='document_strict')",
        )
        .await
        .unwrap();
    server
        .exec("INSERT INTO t (id, name, age) VALUES ('t1', 'bob', 30)")
        .await
        .unwrap();
    server
        .exec("INSERT INTO t (id, name, age) VALUES ('t2', 'alice', 25)")
        .await
        .unwrap();
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn table_name_qualified_where_matches_rows() {
    let server = TestServer::start().await;
    seed(&server).await;

    let rows = server
        .query_text("SELECT id FROM t WHERE t.name = 'bob'")
        .await
        .unwrap();
    assert_eq!(
        rows.len(),
        1,
        "table-qualified WHERE must not return 0 rows"
    );
    assert!(rows[0].contains("t1"));
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn alias_qualified_where_matches_rows() {
    let server = TestServer::start().await;
    seed(&server).await;

    let rows = server
        .query_text("SELECT alias_t.id FROM t alias_t WHERE alias_t.name = 'bob'")
        .await
        .unwrap();
    assert_eq!(
        rows.len(),
        1,
        "alias-qualified WHERE must not return 0 rows"
    );
    assert!(rows[0].contains("t1"));
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn non_pk_qualified_column_matches() {
    let server = TestServer::start().await;
    seed(&server).await;

    // `age` is not the primary key, so this proves the fix isn't only
    // covering the TEXT-PK-equality fast path.
    let rows = server
        .query_text("SELECT id FROM t WHERE t.age = 30")
        .await
        .unwrap();
    assert_eq!(rows.len(), 1);
    assert!(rows[0].contains("t1"));
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn compound_qualified_predicate_matches() {
    let server = TestServer::start().await;
    seed(&server).await;

    let rows = server
        .query_text("SELECT id FROM t WHERE t.name = 'bob' AND t.age = 30")
        .await
        .unwrap();
    assert_eq!(rows.len(), 1);
    assert!(rows[0].contains("t1"));
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn unqualified_where_still_works() {
    let server = TestServer::start().await;
    seed(&server).await;

    let rows = server
        .query_text("SELECT id FROM t WHERE name = 'bob'")
        .await
        .unwrap();
    assert_eq!(rows.len(), 1);
    assert!(rows[0].contains("t1"));
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn qualified_order_by_sorts_single_table() {
    let server = TestServer::start().await;
    seed(&server).await;

    let rows = server
        .query_text("SELECT id FROM t WHERE t.age > 20 ORDER BY t.age")
        .await
        .unwrap();
    assert_eq!(rows.len(), 2, "both rows have age > 20");
    // alice (25) then bob (30) — ascending by the qualified sort key.
    assert!(rows[0].contains("t2"), "ascending order: t2 (age 25) first");
    assert!(
        rows[1].contains("t1"),
        "ascending order: t1 (age 30) second"
    );
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn mismatched_qualifier_errors_instead_of_zero_rows() {
    let server = TestServer::start().await;
    seed(&server).await;

    let result = server
        .query_text("SELECT id FROM t WHERE wrong.name = 'bob'")
        .await;
    assert!(
        result.is_err(),
        "a qualifier that matches neither the table name nor its alias must be a typed error, \
         not a silent 0-row result"
    );
}