scythe-codegen 0.18.0

Polyglot code generation backends for scythe
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

use scythe_codegen::{generate_with_backend, get_backend};
use scythe_core::analyzer::{AnalyzedParam, AnalyzedQuery, CompositeFieldInfo, CompositeInfo};
use scythe_core::parser::QueryCommand;

fn address_composite() -> CompositeInfo {
    CompositeInfo {
        sql_name: "address".to_string(),
        fields: vec![
            CompositeFieldInfo {
                name: "street".to_string(),
                neutral_type: "string".to_string(),
                nullable: false,
            },
            CompositeFieldInfo {
                name: "city".to_string(),
                neutral_type: "string".to_string(),
                nullable: false,
            },
        ],
    }
}

fn composite_param(name: &str, position: i64) -> AnalyzedParam {
    AnalyzedParam {
        name: name.to_string(),
        neutral_type: "composite::address".to_string(),
        nullable: true,
        position,
        source_relation: None,
    }
}

#[test]
fn ruby_pg_encodes_composite_params_and_casts_from_text() {
    let query = AnalyzedQuery::build(|query| {
        query.name = "CreateWidget".to_string();
        query.command = QueryCommand::Exec;
        query.sql = "INSERT INTO widgets (home_address) VALUES ($1)".to_string();
        query.params = vec![composite_param("home_address", 1)];
        query.composites = vec![address_composite()];
    });
    let backend = get_backend("ruby-pg", "postgresql").expect("ruby-pg supports PostgreSQL");
    let composite = backend
        .generate_composite_def(&address_composite())
        .expect("composite generation must succeed");
    let result = generate_with_backend(&query, &*backend).expect("code generation must succeed");
    let query_fn = result.query_fn.expect("exec query must emit a function");

    assert!(
        query_fn.contains("$1::text::address"),
        "missing explicit composite cast:\n{query_fn}"
    );
    assert!(
        query_fn.contains("[home_address&.to_pg_text]"),
        "whole-composite null must remain nil while values are encoded:\n{query_fn}"
    );
    assert!(composite.contains("def to_pg_text"), "missing encoder:\n{composite}");
    assert!(
        composite.contains("self.class._encode_composite_field(street)"),
        "instance encoder must call the generated class helper:\n{composite}"
    );
    assert!(
        composite.contains("raw.empty? || raw.match?(/[(),\\\"\\\\]/) || raw != raw.strip"),
        "encoder must quote empty and structurally significant values:\n{composite}"
    );
    assert!(
        composite.contains(r#"raw.gsub('\\') { '\\\\' }.gsub('"', '""')"#),
        "encoder must escape backslashes and quotes:\n{composite}"
    );
}

#[test]
fn ruby_pg_encoder_preserves_backslashes_at_runtime() {
    let backend = get_backend("ruby-pg", "postgresql").expect("ruby-pg supports PostgreSQL");
    let composite = backend
        .generate_composite_def(&address_composite())
        .expect("composite generation must succeed");
    let script = format!(
        "module Queries\n{composite}\nend\nvalue = Queries::Address.new(street: '12 \"Main\", Apt \\\\3', city: '')\nprint value.to_pg_text"
    );
    let output = std::process::Command::new("ruby")
        .args(["-e", &script])
        .output()
        .expect("ruby must be available for the runtime encoder regression");

    assert!(
        output.status.success(),
        "generated encoder must run: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert_eq!(
        String::from_utf8(output.stdout).expect("encoder output must be UTF-8"),
        r#"("12 ""Main"", Apt \\3","")"#
    );
}

#[test]
fn ruby_pg_encodes_composite_fields_in_multi_param_batches() {
    let query = AnalyzedQuery::build(|query| {
        query.name = "CreateWidget".to_string();
        query.command = QueryCommand::Batch;
        query.sql = "INSERT INTO widgets (kind, home_address) VALUES ($1, $2)".to_string();
        query.params = vec![
            AnalyzedParam {
                name: "kind".to_string(),
                neutral_type: "string".to_string(),
                nullable: false,
                position: 1,
                source_relation: None,
            },
            composite_param("home_address", 2),
        ];
        query.composites = vec![address_composite()];
    });
    let backend = get_backend("ruby-pg", "postgresql").expect("ruby-pg supports PostgreSQL");
    let result = generate_with_backend(&query, &*backend).expect("code generation must succeed");
    let query_fn = result.query_fn.expect("batch query must emit a function");

    assert!(
        query_fn.contains("$2::text::address"),
        "missing batch composite cast:\n{query_fn}"
    );
    assert!(
        query_fn.contains("[item[0], item[1]&.to_pg_text]"),
        "batch must encode only the composite item field:\n{query_fn}"
    );
}