ormer 0.2.4

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
146
147
148
149
150
151
152
153
154

#![cfg(any(feature = "sqlite", feature = "postgresql", feature = "mysql"))]

pub mod _test_common;

// 使用宏定义测试专用模型（每个测试使用唯一表名）
define_test_user_simple!(ValidateTestUserSuccess, "validate_table_success_users_1");
define_test_user_simple!(
    ValidateTestUserNotExists,
    "validate_table_notexists_users_1"
);
define_test_user_simple!(
    ValidateTestUserNoValidation,
    "validate_table_novalidation_users_1"
);

#[cfg(feature = "postgresql")]
#[derive(Debug, ormer::Model, Clone)]
#[table = "validate_table_hypertable_mismatch_1"]
struct ValidateTestHypertable {
    #[primary]
    id: i32,
    #[hypertable(std::time::Duration::from_secs(3600))]
    created_at: chrono::NaiveDateTime,
    name: String,
}

#[cfg(any(feature = "sqlite", feature = "postgresql", feature = "mysql"))]
mod validate_table_tests {
    use super::*;
    use _test_common::{DbConfig, create_db_connection};

    async fn test_validate_table_success_impl(
        config: &DbConfig,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let db = create_db_connection(config).await?;

        // 先删除表（如果存在）
        db.drop_table::<ValidateTestUserSuccess>()
            .execute()
            .await
            .ok();

        // 创建表
        db.create_table::<ValidateTestUserSuccess>()
            .execute()
            .await?;

        // 验证表结构应该成功
        db.validate_table::<ValidateTestUserSuccess>().await?;

        println!("validate_table succeeded for existing table");

        // 清理
        db.drop_table::<ValidateTestUserSuccess>().execute().await?;

        Ok(())
    }

    async fn test_validate_table_not_exists_impl(
        config: &DbConfig,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let db = create_db_connection(config).await?;

        // 确保表不存在
        db.drop_table::<ValidateTestUserNotExists>()
            .execute()
            .await
            .ok();

        // 验证不存在的表应该失败
        // 验证表不存在时的错误处理
        let result = db.validate_table::<ValidateTestUserNotExists>().await;
        assert!(
            result.is_err(),
            "validate_table should fail for non-existent table"
        );

        // 错误已被包装为 ormer::OrmerError，只需验证它确实是错误
        println!("Correctly detected non-existent table: {:?}", result.err());

        Ok(())
    }

    async fn test_create_table_without_validation_impl(
        config: &DbConfig,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let db = create_db_connection(config).await?;

        // 先删除表（如果存在）
        db.drop_table::<ValidateTestUserNoValidation>()
            .execute()
            .await?;

        // 创建表（不应该进行验证）
        db.create_table::<ValidateTestUserNoValidation>()
            .execute()
            .await?;

        println!("create_table succeeded without validation");

        // 清理
        db.drop_table::<ValidateTestUserNoValidation>()
            .execute()
            .await?;

        Ok(())
    }

    #[cfg(feature = "postgresql")]
    async fn test_validate_table_hypertable_mismatch_impl(
        config: &DbConfig,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let db = create_db_connection(config).await?;

        db.drop_table::<ValidateTestHypertable>()
            .execute()
            .await
            .ok();
        db.execute_sql(
            r#"
            CREATE TABLE validate_table_hypertable_mismatch_1 (
                id INTEGER PRIMARY KEY,
                created_at TIMESTAMP NOT NULL,
                name VARCHAR(255) NOT NULL
            )
            "#,
        )
        .await?;

        let result = db.validate_table::<ValidateTestHypertable>().await;
        db.drop_table::<ValidateTestHypertable>().execute().await?;

        let error = result
            .expect_err("validate_table should reject a regular table for a hypertable model");
        assert!(
            format!("{error:?}").contains("Hypertable mismatch"),
            "unexpected error: {error:?}"
        );

        Ok(())
    }

    test_on_all_dbs_result!(test_validate_table_success_impl);
    test_on_all_dbs_result!(test_validate_table_not_exists_impl);
    test_on_all_dbs_result!(test_create_table_without_validation_impl);

    #[cfg(feature = "postgresql")]
    #[tokio::test]
    async fn test_postgresql_validate_table_hypertable_mismatch()
    -> Result<(), Box<dyn std::error::Error>> {
        let config = _test_common::postgresql_config();
        test_validate_table_hypertable_mismatch_impl(&config).await
    }
}