keelson-gen 0.1.1

keelson's code generator: introspect a live schema, emit readable model .rs files against keelson-models.
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

// @generated by keelson-gen. DO NOT EDIT.
// Regenerate from the schema instead; hand-written code (hooks included)
// belongs outside this directory.

/// The model marker `editable_users::table()` hangs off.
#[derive(Debug, Clone, Copy)]
pub struct EditableUsers;
/// One row of `editable_users`.
#[derive(Debug, Clone, PartialEq)]
pub struct EditableUser {
    pub id: i64,
    pub name: Option<String>,
    pub email: Option<String>,
    /// Relations, filled by `preload`/`then_load` mods; empty otherwise.
    pub rel: Rel,
}
/// `editable_users`' relations.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Rel {}
impl keelson_exec::FromRow for EditableUser {
    fn from_row(row: &mut keelson_exec::Row) -> Result<Self, keelson_exec::ExecError> {
        Ok(EditableUser {
            id: row.take("id")?,
            name: row.take("name")?,
            email: row.take("email")?,
            rel: Rel::default(),
        })
    }
}
/// The three-state setter: unset fields stay out of the statement.
#[derive(Debug, Clone, Default)]
pub struct Setter {
    pub id: keelson_models::Set<i64>,
    pub name: keelson_models::Set<String>,
    pub email: keelson_models::Set<String>,
}
/// The entry point: `editable_users::table().query(…)` / `.insert(…)` / ….
pub fn table() -> keelson_models::ModelTable<EditableUsers> {
    keelson_models::ModelTable::new()
}
pub fn id() -> keelson_models::Column<i64> {
    keelson_models::Column::new("editable_users", "id")
}
pub fn name() -> keelson_models::Column<String> {
    keelson_models::Column::new("editable_users", "name")
}
pub fn email() -> keelson_models::Column<String> {
    keelson_models::Column::new("editable_users", "email")
}
#[allow(clippy::type_complexity)]
fn all_columns() -> (
    keelson_models::Column<i64>,
    keelson_models::Column<String>,
    keelson_models::Column<String>,
) {
    (id(), name(), email())
}
impl keelson_models::View for EditableUsers {
    type Row = EditableUser;
    type Select = keelson_sqlite::SelectQuery;
    fn base_select() -> Self::Select {
        keelson_sqlite::select((
            keelson_sqlite::select::columns(all_columns()),
            keelson_sqlite::select::from(keelson_sqlite::quote("editable_users")),
        ))
    }
}
impl keelson_models::Table for EditableUsers {
    type Pk = i64;
    type Setter = Setter;
    type Insert = keelson_sqlite::InsertQuery;
    type Update = keelson_sqlite::UpdateQuery;
    type Delete = keelson_sqlite::DeleteQuery;
    fn insert_query(s: Setter) -> Self::Insert {
        let mut cols: Vec<&'static str> = Vec::new();
        let mut vals: Vec<keelson_core::expr::Expr> = Vec::new();
        s.id.push_into("id", &mut cols, &mut vals);
        s.name.push_into("name", &mut cols, &mut vals);
        s.email.push_into("email", &mut cols, &mut vals);
        let mut q = keelson_sqlite::insert((
            keelson_sqlite::insert::into(keelson_sqlite::quote("editable_users"))
                .columns(cols),
            keelson_sqlite::insert::returning(all_columns()),
        ));
        if !vals.is_empty() {
            q.apply(keelson_sqlite::insert::values(vals));
        }
        q
    }
    fn update_query() -> Self::Update {
        keelson_sqlite::update(
            keelson_sqlite::update::table(keelson_sqlite::quote("editable_users")),
        )
    }
    fn apply_setter(s: Setter, q: &mut Self::Update) {
        if let Some(v) = s.id.into_expr() {
            q.apply(keelson_sqlite::update::set_col("id").to(v));
        }
        if let Some(v) = s.name.into_expr() {
            q.apply(keelson_sqlite::update::set_col("name").to(v));
        }
        if let Some(v) = s.email.into_expr() {
            q.apply(keelson_sqlite::update::set_col("email").to(v));
        }
    }
    fn delete_query() -> Self::Delete {
        keelson_sqlite::delete(
            keelson_sqlite::delete::from(keelson_sqlite::quote("editable_users")),
        )
    }
    fn pk(row: &EditableUser) -> Self::Pk {
        row.id
    }
}