radixdb-sql 1.1.0

SQL syntax contracts and parser for RadixDB
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

use std::fs;
use std::path::PathBuf;

#[test]
fn sql_crate_has_only_the_allowed_internal_dependency() {
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let manifest = fs::read_to_string(crate_dir.join("Cargo.toml")).expect("read SQL manifest");

    let internal_dependencies: Vec<_> = manifest
        .lines()
        .filter(|line| line.trim_start().starts_with("radixdb-"))
        .collect();
    assert_eq!(
        internal_dependencies,
        ["radixdb-core = { path = \"../radixdb-core\" }"]
    );
}

#[test]
fn root_token_module_is_a_compatibility_facade() {
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let workspace = crate_dir
        .parent()
        .and_then(|path| path.parent())
        .expect("radixdb-sql lives below the workspace root");
    let source = fs::read_to_string(workspace.join("src/lib.rs")).expect("read root facade");

    assert!(source.contains("pub use radixdb_sql as parser;"));
    assert!(!workspace.join("src/parser").exists());
    assert!(!source.contains("pub struct "));
    assert!(!source.contains("pub enum "));
    assert!(!source.contains("static KEYWORD_SET"));
}

#[test]
fn root_lexer_module_is_a_compatibility_facade() {
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let workspace = crate_dir
        .parent()
        .and_then(|path| path.parent())
        .expect("radixdb-sql lives below the workspace root");
    let source = fs::read_to_string(workspace.join("src/lib.rs")).expect("read root facade");

    assert!(source.contains("pub use radixdb_sql as parser;"));
    assert!(!workspace.join("src/parser").exists());
    assert!(!source.contains("pub struct Lexer"));
    assert!(!source.contains("impl Lexer"));
}

#[test]
fn root_ast_module_is_a_compatibility_facade() {
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let workspace = crate_dir
        .parent()
        .and_then(|path| path.parent())
        .expect("radixdb-sql lives below the workspace root");
    let source = fs::read_to_string(workspace.join("src/lib.rs")).expect("read root facade");

    assert!(source.contains("pub use radixdb_sql as parser;"));
    assert!(!workspace.join("src/parser").exists());
    assert!(!source.contains("pub struct "));
    assert!(!source.contains("pub enum "));
    assert!(!source.contains("impl "));
}

#[test]
fn ast_is_split_into_bounded_functional_modules() {
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let ast_dir = crate_dir.join("src/ast");

    for name in [
        "control.rs",
        "ddl.rs",
        "dml.rs",
        "expression.rs",
        "query.rs",
        "source.rs",
        "statement.rs",
        "visitor.rs",
    ] {
        let source = fs::read_to_string(ast_dir.join(name)).expect("read AST module");
        assert!(
            source.lines().count() <= 1_500,
            "AST module {name} grew beyond the migration contract"
        );
    }
}

#[test]
fn root_parser_support_modules_do_not_own_parser_implementations() {
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let workspace = crate_dir
        .parent()
        .and_then(|path| path.parent())
        .expect("radixdb-sql lives below the workspace root");
    assert!(!workspace.join("src/parser").exists());
}

#[test]
fn root_parser_module_is_only_a_facade() {
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let workspace = crate_dir
        .parent()
        .and_then(|path| path.parent())
        .expect("radixdb-sql lives below the workspace root");
    let source = fs::read_to_string(workspace.join("src/lib.rs")).expect("read root facade");

    assert!(source.contains("pub use radixdb_sql as parser;"));
    assert!(!workspace.join("src/parser").exists());
    assert!(!source.contains("pub fn parse_sql"));
    assert!(!source.contains("mod expressions"));
    assert!(!source.contains("mod statements"));
}

#[test]
fn statement_grammar_is_split_into_bounded_functional_modules() {
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let statements_dir = crate_dir.join("src/statements");

    for name in ["control.rs", "ddl.rs", "dispatch.rs", "dml.rs", "query.rs"] {
        let source =
            fs::read_to_string(statements_dir.join(name)).expect("read statement grammar module");
        assert!(
            source.lines().count() <= 1_500,
            "statement module {name} grew beyond the migration contract"
        );
    }
}