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
136
137
138
139
140
141
142
143
144
145
146
147

// SPDX-License-Identifier: BUSL-1.1

//! Integration coverage for UTF-8 correctness in expression parsing.
//!
//! The expression tokenizer in `nodedb-query` iterates byte-by-byte but
//! slices `&str` — panicking on multi-byte UTF-8 codepoints. These tests
//! verify that non-ASCII characters in generated columns, check constraints,
//! and typeguard expressions do not cause panics or data corruption.

mod common;

use common::pgwire_harness::TestServer;

/// A GENERATED ALWAYS AS expression containing a CJK literal must not panic.
/// The tokenizer slices `&input[i..i+2]` which crosses a char boundary on
/// 3-byte UTF-8 codepoints.
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn generated_column_with_cjk_literal_does_not_panic() {
    let server = TestServer::start().await;

    let result = server
        .exec(
            "CREATE COLLECTION utf_gen (\
                id TEXT PRIMARY KEY, \
                x TEXT, \
                y TEXT GENERATED ALWAYS AS ('你' || x)) WITH (engine='document_strict')",
        )
        .await;
    assert!(
        result.is_ok(),
        "CJK literal in GENERATED expression should not panic: {:?}",
        result
    );

    server
        .exec("INSERT INTO utf_gen (id, x) VALUES ('u1', 'hello')")
        .await
        .unwrap();

    let rows = server
        .query_text("SELECT y FROM utf_gen WHERE id = 'u1'")
        .await
        .unwrap();
    assert_eq!(rows.len(), 1);
    assert!(
        rows[0].contains("你hello"),
        "generated column should concatenate CJK prefix: got {:?}",
        rows[0]
    );
}

/// Emoji (4-byte UTF-8) in an expression must not panic.
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn generated_column_with_emoji_does_not_panic() {
    let server = TestServer::start().await;

    let result = server
        .exec(
            "CREATE COLLECTION utf_emoji (\
                id TEXT PRIMARY KEY, \
                tag TEXT, \
                display TEXT GENERATED ALWAYS AS ('🎉' || tag)) WITH (engine='document_strict')",
        )
        .await;
    assert!(
        result.is_ok(),
        "emoji in GENERATED expression should not panic: {:?}",
        result
    );
}

/// Multi-byte characters followed by operators (`<=`, `>=`, `!=`, `||`)
/// are the specific trigger for the `&input[i..i+2]` boundary panic.
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn check_constraint_with_utf8_near_operator() {
    let server = TestServer::start().await;

    server
        .exec(
            "CREATE COLLECTION utf_ck (\
                id TEXT PRIMARY KEY, \
                name TEXT) WITH (engine='document_strict')",
        )
        .await
        .unwrap();

    // Check constraint with a multi-byte literal adjacent to `!=`
    let result = server
        .exec(
            "ALTER COLLECTION utf_ck ADD CONSTRAINT no_forbidden \
             CHECK (NEW.name != '禁止')",
        )
        .await;
    assert!(
        result.is_ok(),
        "CHECK with UTF-8 literal near != operator should not panic: {:?}",
        result
    );

    // Valid insert should pass the constraint.
    server
        .exec("INSERT INTO utf_ck (id, name) VALUES ('c1', 'allowed')")
        .await
        .unwrap();

    let rows = server
        .query_text("SELECT id FROM utf_ck WHERE id = 'c1'")
        .await
        .unwrap();
    assert_eq!(rows.len(), 1);
}

/// Latin diacritics (2-byte UTF-8) in expression strings.
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn generated_column_with_latin_diacritics() {
    let server = TestServer::start().await;

    let result = server
        .exec(
            "CREATE COLLECTION utf_lat (\
                id TEXT PRIMARY KEY, \
                city TEXT, \
                greeting TEXT GENERATED ALWAYS AS ('café in ' || city)) WITH (engine='document_strict')",
        )
        .await;
    assert!(
        result.is_ok(),
        "Latin diacritics in GENERATED expression should not panic: {:?}",
        result
    );

    server
        .exec("INSERT INTO utf_lat (id, city) VALUES ('l1', 'Paris')")
        .await
        .unwrap();

    let rows = server
        .query_text("SELECT greeting FROM utf_lat WHERE id = 'l1'")
        .await
        .unwrap();
    assert_eq!(rows.len(), 1);
    assert!(
        rows[0].contains("café in Paris"),
        "generated column should preserve diacritics: got {:?}",
        rows[0]
    );
}