tank 0.30.0

Tank (Table Abstraction and Navigation Kit): the Rust data layer. Simple and flexible ORM that allows to manage in a unified way data from different sources.
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

#[cfg(test)]
mod tests {
    use indoc::indoc;
    use std::borrow::Cow;
    use tank::{DynQuery, Entity, GenericSqlWriter, QueryBuilder, SqlWriter, TableRef};

    #[derive(Entity, Default)]
    #[tank(schema = "the_schema", name = "empty_entity")]
    struct SomeEmptyEntity {}

    const WRITER: GenericSqlWriter = GenericSqlWriter {};

    #[test]
    fn test_simple_entity() {
        assert!(matches!(
            SomeEmptyEntity::table(),
            TableRef {
                name: Cow::Borrowed("empty_entity"),
                schema: Cow::Borrowed("the_schema"),
                alias: Cow::Borrowed(""),
                ..
            }
        ));

        assert_eq!(SomeEmptyEntity::primary_key_def().len(), 0);

        let columns = SomeEmptyEntity::columns();
        assert_eq!(columns.len(), 0);
    }

    #[test]
    fn test_simple_entity_create_table() {
        let mut query = DynQuery::default();
        WRITER.write_create_table::<SomeEmptyEntity>(&mut query, true);
        assert_eq!(
            query.as_str(),
            indoc! {r#"
                CREATE TABLE IF NOT EXISTS "the_schema"."empty_entity" (
                );
            "#}
            .trim()
        );
    }

    #[test]
    fn test_simple_entity_drop_table() {
        let mut query = DynQuery::default();
        WRITER.write_drop_table::<SomeEmptyEntity>(&mut query, false);
        assert_eq!(query.as_str(), r#"DROP TABLE "the_schema"."empty_entity";"#);
    }

    #[test]
    fn test_simple_entity_select() {
        let mut query = DynQuery::default();
        WRITER.write_select(
            &mut query,
            &QueryBuilder::new()
                .select(SomeEmptyEntity::columns())
                .from(SomeEmptyEntity::table()),
        );
        assert_eq!(
            query.as_str(),
            indoc! {r#"
                SELECT *
                FROM "the_schema"."empty_entity";
            "#}
            .trim()
        );
    }

    #[test]
    fn test_simple_entity_insert() {
        let mut query = DynQuery::default();
        WRITER.write_insert(&mut query, [&SomeEmptyEntity::default()], true);
        assert_eq!(
            query.as_str(),
            indoc! {r#"
                INSERT INTO "the_schema"."empty_entity" () VALUES
                ();
            "#}
            .trim()
        );
    }

    #[test]
    fn test_simple_entity_delete() {
        let mut query = DynQuery::default();
        WRITER.write_delete::<SomeEmptyEntity>(&mut query, false);
        assert_eq!(
            query.as_str(),
            indoc! {r#"
                DELETE FROM "the_schema"."empty_entity"
                WHERE false;
            "#}
            .trim()
        );
    }
}