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

// SPDX-License-Identifier: BUSL-1.1

//! PostgreSQL-compatible `regclass` input and output semantics.

mod common;

use common::pgwire_harness::TestServer;

#[tokio::test]
async fn quoted_relation_name_resolves_like_the_unquoted_form() {
    let srv = TestServer::start().await;
    srv.exec(
        "CREATE COLLECTION quoted_regclass_target \
         (id BIGINT PRIMARY KEY, name TEXT DEFAULT 'x', qty INT) \
         WITH (engine='document_strict')",
    )
    .await
    .expect("create collection");

    let mut bare = srv
        .query_text(
            "SELECT attname FROM pg_attribute \
             WHERE attrelid = 'quoted_regclass_target'::regclass",
        )
        .await
        .expect("bare regclass lookup");
    let mut quoted = srv
        .query_text(
            "SELECT attname FROM pg_attribute \
             WHERE attrelid = '\"quoted_regclass_target\"'::regclass",
        )
        .await
        .expect("quoted regclass lookup");
    bare.sort();
    quoted.sort();

    assert_eq!(bare, vec!["id", "name", "qty"]);
    assert_eq!(
        quoted, bare,
        "identifier quotes inside a regclass string must be normalized before lookup"
    );
}

#[tokio::test]
async fn default_schema_qualifier_resolves_the_same_relation() {
    let srv = TestServer::start().await;
    srv.exec(
        "CREATE COLLECTION qualified_regclass_target \
         (id BIGINT PRIMARY KEY, name TEXT DEFAULT 'x', qty INT) \
         WITH (engine='document_strict')",
    )
    .await
    .expect("create collection");

    let mut qualified = srv
        .query_text(
            "SELECT attname FROM pg_attribute \
             WHERE attrelid = 'public.\"qualified_regclass_target\"'::regclass",
        )
        .await
        .expect("schema-qualified regclass lookup");
    qualified.sort();

    assert_eq!(
        qualified,
        vec!["id", "name", "qty"],
        "the default schema qualifier must resolve through the same relation identity"
    );
}

#[tokio::test]
async fn unknown_regclass_cast_reports_undefined_relation() {
    let srv = TestServer::start().await;
    srv.expect_error("SELECT 'missing_regclass_target'::regclass", "42P01")
        .await;
}

#[tokio::test]
async fn regclass_validation_covers_update_and_delete_filters() {
    let srv = TestServer::start().await;
    srv.exec("CREATE COLLECTION regclass_dml_target (id BIGINT PRIMARY KEY, value TEXT)")
        .await
        .expect("create collection");
    srv.expect_error(
        "UPDATE regclass_dml_target SET value = 'x' \
         WHERE 'missing_update_relation'::regclass = 1",
        "42P01",
    )
    .await;
    srv.expect_error(
        "DELETE FROM regclass_dml_target \
         WHERE 'missing_delete_relation'::regclass = 1",
        "42P01",
    )
    .await;
}

#[tokio::test]
async fn regclass_validation_covers_projection_and_aggregate_expressions() {
    let srv = TestServer::start().await;
    srv.exec("CREATE COLLECTION regclass_expr_target (id BIGINT PRIMARY KEY)")
        .await
        .expect("create collection");
    srv.expect_error(
        "SELECT 'missing_projection_relation'::regclass FROM regclass_expr_target",
        "42P01",
    )
    .await;
    srv.expect_error(
        "SELECT COUNT('missing_aggregate_relation'::regclass) FROM regclass_expr_target",
        "42P01",
    )
    .await;
}

#[tokio::test]
async fn direct_regclass_cast_renders_the_relation_name() {
    let srv = TestServer::start().await;
    srv.exec("CREATE COLLECTION rendered_regclass_target (id BIGINT PRIMARY KEY)")
        .await
        .expect("create collection");

    let bare = srv
        .query_text("SELECT 'rendered_regclass_target'::regclass")
        .await
        .expect("render bare regclass");
    let quoted = srv
        .query_text("SELECT '\"rendered_regclass_target\"'::regclass")
        .await
        .expect("render quoted regclass");

    assert_eq!(bare, vec!["rendered_regclass_target"]);
    assert_eq!(quoted, bare);
    assert!(
        bare.iter().all(|value| !value.is_empty()),
        "resolved regclass values must never render as empty cells"
    );
}