asn1rs 0.1.17

ASN.1 to Rust, Protobuf and SQL compiler/code generator. Supports ASN.1 UPER
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

use crate::gen::RustCodeGenerator;
use crate::model::sql::Sql;
use crate::model::{Model, RustType};

pub(crate) fn select_statement_single(name: &str) -> String {
    format!("SELECT * FROM {} WHERE id = $1", name)
}

#[cfg(feature = "async-psql")]
pub(crate) fn select_statement_many(name: &str) -> String {
    format!("SELECT * FROM {} WHERE id = ANY($1)", name)
}

pub(crate) fn tuple_struct_insert_statement(name: &str) -> String {
    format!("INSERT INTO {} DEFAULT VALUES RETURNING id", name)
}

pub(crate) fn struct_insert_statement(name: &str, fields: &[(String, RustType)]) -> String {
    format!(
        "INSERT INTO {}({}) VALUES({}) RETURNING id",
        name,
        fields
            .iter()
            .filter_map(|(name, field)| if field.is_vec() {
                None
            } else {
                Some(Model::sql_column_name(name))
            })
            .collect::<Vec<String>>()
            .join(", "),
        fields
            .iter()
            .filter_map(|(name, field)| if field.is_vec() { None } else { Some(name) })
            .enumerate()
            .map(|(num, _)| format!("${}", num + 1))
            .collect::<Vec<String>>()
            .join(", "),
    )
}

pub(crate) fn data_enum_insert_statement(name: &str, fields: &[(String, RustType)]) -> String {
    format!(
        "INSERT INTO {}({}) VALUES({}) RETURNING id",
        name,
        fields
            .iter()
            .map(|(name, _)| RustCodeGenerator::rust_module_name(name))
            .collect::<Vec<String>>()
            .join(", "),
        fields
            .iter()
            .enumerate()
            .map(|(num, _)| format!("${}", num + 1))
            .collect::<Vec<String>>()
            .join(", "),
    )
}

pub(crate) fn struct_list_entry_insert_statement(struct_name: &str, field_name: &str) -> String {
    format!(
        "INSERT INTO {}(list, value) VALUES ($1, $2)",
        Model::<Sql>::struct_list_entry_table_name(struct_name, field_name),
    )
}

pub(crate) fn struct_list_entry_select_referenced_value_statement(
    struct_name: &str,
    field_name: &str,
    other_type: &str,
) -> String {
    let listentry_table = Model::<Sql>::struct_list_entry_table_name(struct_name, field_name);
    format!(
        "SELECT * FROM {} WHERE id IN (SELECT value FROM {} WHERE list = $1)",
        RustCodeGenerator::rust_variant_name(other_type),
        listentry_table,
    )
}

pub(crate) fn struct_list_entry_select_value_statement(
    struct_name: &str,
    field_name: &str,
) -> String {
    let listentry_table = Model::<Sql>::struct_list_entry_table_name(struct_name, field_name);
    format!("SELECT value FROM {} WHERE list = $1", listentry_table,)
}

pub(crate) fn list_entry_insert_statement(name: &str) -> String {
    format!("INSERT INTO {}ListEntry(list, value) VALUES ($1, $2)", name)
}

pub(crate) fn list_entry_query_statement(name: &str, inner: &RustType) -> String {
    if Model::<Sql>::is_primitive(inner) {
        format!(
            "SELECT value FROM {}ListEntry WHERE {}ListEntry.list = $1",
            name, name
        )
    } else {
        let inner = inner.clone().into_inner_type().to_string();
        format!(
            "SELECT * FROM {} INNER JOIN {}ListEntry ON {}.id = {}ListEntry.value WHERE {}ListEntry.list = $1",
            inner, name, inner, name, name
        )
    }
}