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

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

mod _test_common;

// 使用宏定义测试专用模型（唯一表名）
define_test_user!(SetModelUser, "set_model_users_1");

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

    // 插入初始用户
    db.insert(&SetModelUser {
        id: 1,
        name: "Alice".to_string(),
        age: 18,
        email: None,
    })
    .execute()
    .await?;

    // 使用 set_model 更新所有非主键字段
    let updated_user = SetModelUser {
        id: 1,
        name: "Bob".to_string(),
        age: 25,
        email: Some("bob@test.com".to_string()),
    };
    db.update::<SetModelUser>()
        .set_model(&updated_user)
        .execute()
        .await?;

    // 验证更新结果
    let users: Vec<SetModelUser> = db
        .select::<SetModelUser>()
        .filter(|p| p.id.eq(1))
        .collect::<Vec<_>>()
        .await?;
    assert_eq!(users.len(), 1);
    assert_eq!(users[0].name, "Bob");
    assert_eq!(users[0].age, 25);
    assert_eq!(users[0].email, Some("bob@test.com".to_string()));

    // 测试第二个用户的 set_model 更新
    db.insert(&SetModelUser {
        id: 2,
        name: "Charlie".to_string(),
        age: 20,
        email: None,
    })
    .execute()
    .await?;

    let user2 = SetModelUser {
        id: 2,
        name: "David".to_string(),
        age: 30,
        email: Some("david@test.com".to_string()),
    };
    db.update::<SetModelUser>()
        .set_model(&user2)
        .execute()
        .await?;

    let users2: Vec<SetModelUser> = db
        .select::<SetModelUser>()
        .filter(|p| p.id.eq(2))
        .collect::<Vec<_>>()
        .await?;
    assert_eq!(users2.len(), 1);
    assert_eq!(users2[0].name, "David");
    assert_eq!(users2[0].age, 30);

    // 验证用户1没有被第二次更新影响
    let users1: Vec<SetModelUser> = db
        .select::<SetModelUser>()
        .filter(|p| p.id.eq(1))
        .collect::<Vec<_>>()
        .await?;
    assert_eq!(users1.len(), 1);
    assert_eq!(users1[0].name, "Bob");

    // 字段白名单更新只修改指定列
    let partial_user = SetModelUser {
        id: 1,
        name: "Carol".to_string(),
        age: 99,
        email: Some("carol@test.com".to_string()),
    };
    db.update::<SetModelUser>()
        .set_model_fields(&partial_user, |p| (p.name, p.email))
        .execute()
        .await?;

    let partial_users: Vec<SetModelUser> = db
        .select::<SetModelUser>()
        .filter(|p| p.id.eq(1))
        .collect::<Vec<_>>()
        .await?;
    assert_eq!(partial_users.len(), 1);
    assert_eq!(partial_users[0].name, "Carol");
    assert_eq!(partial_users[0].age, 25);
    assert_eq!(partial_users[0].email, Some("carol@test.com".to_string()));

    let increment_sql = db
        .update::<SetModelUser>()
        .filter(|p| p.id.eq(1))
        .set(|p| p.age += 1)
        .to_sql()?;
    assert!(increment_sql.statements[0].sql.contains("age = age +"));

    db.update::<SetModelUser>()
        .filter(|p| p.id.eq(1))
        .set(|p| p.age += 1)
        .execute()
        .await?;

    let incremented_users: Vec<SetModelUser> = db
        .select::<SetModelUser>()
        .filter(|p| p.id.eq(1))
        .collect::<Vec<_>>()
        .await?;
    assert_eq!(incremented_users.len(), 1);
    assert_eq!(incremented_users[0].age, 26);

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

    Ok(())
}

test_on_all_dbs_result!(test_set_model_impl);