rok-sqlc 0.6.0

Generate SQLx Rust database modules from SQL schema files
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

//! Parser tests, grouped by behaviour.

use super::*;

mod alter_column;
mod alter_table;
mod check_rules;
mod create_table;
mod enums;
mod recovered;
mod value_lists;

fn parse(sql: &str) -> ParsedSchema {
    parse_schema(sql).expect("schema should parse")
}

fn one_table(sql: &str) -> Table {
    let parsed = parse(sql);
    assert!(
        parsed.failures.is_empty(),
        "unexpected failures: {:?}",
        parsed.failures
    );
    assert_eq!(parsed.schema.tables.len(), 1);
    parsed.schema.tables[0].clone()
}

fn parse_files(files: &[(&str, &str)]) -> ParsedSchema {
    let sources: Vec<SchemaSource<'_>> = files
        .iter()
        .map(|(path, sql)| SchemaSource {
            path: Path::new(path),
            sql,
        })
        .collect();
    parse_sources(&sources).expect("schema should parse")
}

fn column_names(table: &Table) -> Vec<&str> {
    table
        .columns
        .iter()
        .map(|column| column.sql_name.as_str())
        .collect()
}

fn enum_summary(schema: &Schema) -> Vec<(String, Option<&str>, Vec<&str>)> {
    schema
        .enums
        .iter()
        .map(|enum_type| {
            (
                enum_type.rust_name.clone(),
                enum_type.column.as_deref(),
                enum_type
                    .variants
                    .iter()
                    .map(|variant| variant.label.as_str())
                    .collect(),
            )
        })
        .collect()
}