ormer 0.2.14

A minimalist ORM framework that supports SQLite, PostgreSQL, MySQL, and SqlServer
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

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

//! schema 限定表（`#[table = "schema.table"]`）的建表端到端验证：
//! 目标 schema 不存在时，`ensure_table` 必须先自动补建 schema 再建表，
//! 且重复执行幂等。

use ormer::{Database, DbType};

#[derive(Debug, Clone, ormer::Model)]
#[table = "ormer_schema_e2e.schema_users"]
struct SchemaUser {
    #[primary]
    id: i32,
    #[index]
    name: String,
}

#[derive(Debug, Clone, ormer::Model)]
#[table = "ormer_schema_e2e_p.schema_users"]
struct PermissiveSchemaUser {
    #[primary]
    id: i32,
    #[index]
    name: String,
}

async fn connect() -> Result<Database, Box<dyn std::error::Error>> {
    let connection_string = option_env!("ORMER_TEST_POSTGRES")
        .filter(|value| !value.is_empty())
        .unwrap_or("postgres://postgres:postgres@localhost:5432/ormer_test");
    Ok(Database::connect(DbType::PostgreSQL, connection_string).await?)
}

async fn schema_exists(db: &Database, schema: &str) -> bool {
    db.select_sql::<bool>(&format!(
        "SELECT EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = '{schema}')"
    ))
    .collect::<Vec<bool>>()
    .await
    .expect("query schemata")
    .into_iter()
    .next()
    .unwrap_or(false)
}

async fn table_exists(db: &Database, schema: &str, table: &str) -> bool {
    db.select_sql::<bool>(&format!(
        "SELECT EXISTS (SELECT 1 FROM information_schema.tables \
         WHERE table_schema = '{schema}' AND table_name = '{table}')"
    ))
    .collect::<Vec<bool>>()
    .await
    .expect("query tables")
    .into_iter()
    .next()
    .unwrap_or(false)
}

#[tokio::test]
async fn ensure_table_creates_missing_schema() -> Result<(), Box<dyn std::error::Error>> {
    let db = connect().await?;

    // 从干净状态开始：schema 与表都不存在
    db.execute_sql("DROP TABLE IF EXISTS ormer_schema_e2e.schema_users")
        .await?;
    db.execute_sql("DROP SCHEMA IF EXISTS ormer_schema_e2e CASCADE")
        .await?;
    assert!(!schema_exists(&db, "ormer_schema_e2e").await);

    // 首次 ensure_table：应自动建 schema + 表
    let outcome = db.ensure_table::<SchemaUser>().await?;
    assert!(matches!(
        outcome,
        ormer::TableEnsureOutcome::Ready | ormer::TableEnsureOutcome::Migrated
    ));
    assert!(schema_exists(&db, "ormer_schema_e2e").await);
    assert!(table_exists(&db, "ormer_schema_e2e", "schema_users").await);

    // 幂等：二次执行不报错，且写入可用
    let outcome = db.ensure_table::<SchemaUser>().await?;
    assert_eq!(outcome, ormer::TableEnsureOutcome::Ready);
    db.insert(&SchemaUser { id: 1, name: "alice".into() })
        .execute()
        .await?;

    // 删表不删 schema：ensure_table 只补表
    db.drop_table::<SchemaUser>().execute().await?;
    assert!(!table_exists(&db, "ormer_schema_e2e", "schema_users").await);
    db.ensure_table::<SchemaUser>().await?;
    assert!(table_exists(&db, "ormer_schema_e2e", "schema_users").await);

    Ok(())
}

#[tokio::test]
async fn ensure_table_permissive_creates_missing_schema() -> Result<(), Box<dyn std::error::Error>> {
    let db = connect().await?;

    db.execute_sql("DROP SCHEMA IF EXISTS ormer_schema_e2e_p CASCADE")
        .await?;
    db.ensure_table_permissive::<PermissiveSchemaUser>().await?;
    assert!(
        table_exists(&db, "ormer_schema_e2e_p", "schema_users").await,
        "permissive ensure should create missing schema and table"
    );

    Ok(())
}