spg-sql 7.10.8

Self-built SQL front-end for SPG: PG-dialect lexer + parser. no_std + alloc.
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

//! v7.9.18 — parser coverage for table-level UNIQUE / PRIMARY KEY
//! clauses. mailrs migration follow-up G1 + G6.

use spg_sql::ast::{Statement, TableConstraint};
use spg_sql::parser::parse_statement;

fn create_table_constraints(sql: &str) -> Vec<TableConstraint> {
    match parse_statement(sql).expect("parses") {
        Statement::CreateTable(t) => t.table_constraints,
        other => panic!("expected CREATE TABLE, got {other:?}"),
    }
}

#[test]
fn table_level_unique_single_column_parses() {
    let cs = create_table_constraints(
        "CREATE TABLE u (id INT NOT NULL, address TEXT NOT NULL, UNIQUE (address))",
    );
    assert_eq!(cs.len(), 1);
    let TableConstraint::Unique { columns, .. } = &cs[0] else { panic!() };
    assert_eq!(columns, &vec!["address".to_string()]);
}

#[test]
fn table_level_unique_composite_parses() {
    // mailrs `messages` IMAP UID uniqueness pattern.
    let cs = create_table_constraints(
        "CREATE TABLE messages (\
            id BIGSERIAL,\
            mailbox_id BIGINT NOT NULL,\
            uid INTEGER NOT NULL,\
            UNIQUE (mailbox_id, uid)\
        )",
    );
    assert_eq!(cs.len(), 1);
    let TableConstraint::Unique { columns, .. } = &cs[0] else { panic!() };
    assert_eq!(columns.len(), 2);
}

#[test]
fn composite_primary_key_parses() {
    // mailrs snoozed_conversations pattern.
    let cs = create_table_constraints(
        "CREATE TABLE snoozed (\
            thread_id TEXT NOT NULL,\
            account_address TEXT NOT NULL,\
            PRIMARY KEY (thread_id, account_address)\
        )",
    );
    assert_eq!(cs.len(), 1);
    let TableConstraint::PrimaryKey { columns, .. } = &cs[0] else { panic!() };
    assert_eq!(columns, &vec!["thread_id".to_string(), "account_address".to_string()]);
}

#[test]
fn table_with_both_pk_and_unique_constraints() {
    let cs = create_table_constraints(
        "CREATE TABLE t (\
            a INT NOT NULL,\
            b INT NOT NULL,\
            c INT NOT NULL,\
            PRIMARY KEY (a),\
            UNIQUE (b, c)\
        )",
    );
    assert_eq!(cs.len(), 2);
}

#[test]
fn table_constraints_interleaved_with_inline_fk() {
    // PRIMARY KEY at end after inline FOREIGN KEY clause.
    let stmt = parse_statement(
        "CREATE TABLE child (\
            id INT NOT NULL,\
            parent_id INT NOT NULL,\
            extra INT NOT NULL,\
            FOREIGN KEY (parent_id) REFERENCES parent(id),\
            UNIQUE (id, extra)\
        )",
    )
    .unwrap();
    let Statement::CreateTable(t) = stmt else { panic!() };
    assert_eq!(t.foreign_keys.len(), 1);
    assert_eq!(t.table_constraints.len(), 1);
}

#[test]
fn unique_without_parens_is_rejected() {
    let r = parse_statement("CREATE TABLE t (a INT NOT NULL, UNIQUE a)");
    assert!(r.is_err());
}

#[test]
fn primary_key_without_columns_is_rejected() {
    let r = parse_statement("CREATE TABLE t (a INT NOT NULL, PRIMARY KEY ())");
    assert!(r.is_err());
}

#[test]
fn table_level_unique_after_many_columns() {
    // Stress: 5 columns + composite unique on the last 2.
    let cs = create_table_constraints(
        "CREATE TABLE t (\
            a INT NOT NULL,\
            b INT NOT NULL,\
            c INT NOT NULL,\
            d INT NOT NULL,\
            e INT NOT NULL,\
            UNIQUE (d, e)\
        )",
    );
    let TableConstraint::Unique { columns, .. } = &cs[0] else { panic!() };
    assert_eq!(columns, &vec!["d".to_string(), "e".to_string()]);
}