ormer 0.2.2

A minimalist ORM framework that supports SQLite, PostgreSQL, MySQL, and SqlServer
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#![cfg(feature = "postgresql")]

mod _test_common;

#[derive(Debug, Clone, PartialEq, ormer::Model)]
#[table = "test_postgresql_arrays_1"]
struct PgArrayModel {
    #[primary]
    id: i32,
    ints: Vec<i32>,
    bigints: Vec<i64>,
    nullable_bigints: Vec<Option<i64>>,
}

#[derive(Debug, Clone, Copy, PartialEq)]
#[repr(i32)]
enum PgArrayRole {
    Admin = 1,
    Ops = 2,
}

impl TryFrom<i32> for PgArrayRole {
    type Error = &'static str;

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::Admin),
            2 => Ok(Self::Ops),
            _ => Err("unknown role"),
        }
    }
}

#[derive(Debug, Clone, PartialEq, ormer::Model)]
#[table = "test_postgresql_arrays_2"]
struct PgEnumArrayModel {
    #[primary]
    id: i32,
    #[data_type(Vec<i32>)]
    roles: Vec<PgArrayRole>,
}

#[derive(Debug, Clone, PartialEq, ormer::Model)]
#[table = "test_postgresql_arrays_3"]
struct PgStringArrayModel {
    #[primary]
    id: i32,
    tags: Vec<String>,
}

#[tokio::test]
async fn test_postgresql_array_sql_and_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
    let config = _test_common::postgresql_config();

    let sql = ormer::generate_create_table_sql::<PgArrayModel>(config.0)?;
    assert!(sql.contains("ints INTEGER[] NOT NULL"), "{sql}");
    assert!(sql.contains("bigints BIGINT[] NOT NULL"), "{sql}");
    assert!(sql.contains("nullable_bigints BIGINT[] NOT NULL"), "{sql}");

    let db = _test_common::create_db_connection(&config).await?;
    let _ = db.drop_table::<PgArrayModel>().execute().await;

    db.create_table::<PgArrayModel>().execute().await?;
    db.validate_table::<PgArrayModel>().await?;

    let model = PgArrayModel {
        id: 1,
        ints: vec![1, 2, 3],
        bigints: vec![10, 20, 30],
        nullable_bigints: vec![Some(100), None, Some(300)],
    };

    db.insert(&model).execute().await?;

    let items = db.select::<PgArrayModel>().collect::<Vec<_>>().await?;
    assert_eq!(items, vec![model]);

    db.drop_table::<PgArrayModel>().execute().await?;
    Ok(())
}

#[tokio::test]
async fn test_postgresql_enum_array_data_type_roundtrip() -> Result<(), Box<dyn std::error::Error>>
{
    let config = _test_common::postgresql_config();

    let sql = ormer::generate_create_table_sql::<PgEnumArrayModel>(config.0)?;
    assert!(sql.contains("roles INTEGER[] NOT NULL"), "{sql}");

    let db = _test_common::create_db_connection(&config).await?;
    let _ = db.drop_table::<PgEnumArrayModel>().execute().await;

    db.create_table::<PgEnumArrayModel>().execute().await?;
    db.validate_table::<PgEnumArrayModel>().await?;

    let model = PgEnumArrayModel {
        id: 1,
        roles: vec![PgArrayRole::Admin, PgArrayRole::Ops],
    };

    db.insert(&model).execute().await?;

    let items = db.select::<PgEnumArrayModel>().collect::<Vec<_>>().await?;
    assert_eq!(items, vec![model]);

    db.drop_table::<PgEnumArrayModel>().execute().await?;
    Ok(())
}

#[tokio::test]
async fn test_postgresql_string_array_uses_text_array_value()
-> Result<(), Box<dyn std::error::Error>> {
    let config = _test_common::postgresql_config();

    let sql = ormer::generate_create_table_sql::<PgStringArrayModel>(config.0)?;
    assert!(sql.contains("tags TEXT[] NOT NULL"), "{sql}");

    let model = PgStringArrayModel {
        id: 1,
        tags: vec!["alpha".to_string(), "beta".to_string()],
    };

    let values = <PgStringArrayModel as ormer::Model>::field_values(&model);
    match &values[1] {
        ormer::Value::TextArray(tags) => assert_eq!(tags, &model.tags),
        other => panic!("expected TextArray value, got {:?}", other),
    }

    let db = _test_common::create_db_connection(&config).await?;
    let _ = db.drop_table::<PgStringArrayModel>().execute().await;

    db.create_table::<PgStringArrayModel>().execute().await?;
    db.validate_table::<PgStringArrayModel>().await?;

    db.insert(&model).execute().await?;

    let items = db
        .select::<PgStringArrayModel>()
        .collect::<Vec<_>>()
        .await?;
    assert_eq!(items, vec![model]);

    db.drop_table::<PgStringArrayModel>().execute().await?;
    Ok(())
}