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

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

mod _test_common;

// 使用宏定义测试专用模型（唯一表名）
define_test_user_simple!(TestUser, "test_collect_users_1");
define_test_role_for_collect!(TestRole, "test_collect_roles_1");

// 单字段Model，用于测试collect_with
define_test_user_id!(UserId, "test_collect_user_ids_1");

async fn test_collect_with_impl(
    config: &_test_common::DbConfig,
) -> Result<(), Box<dyn std::error::Error>> {
    // 创建内存数据库
    let db = _test_common::create_db_connection(config).await?;
    println!("[TEST] Created database connection");

    // 先删除表（如果存在）
    let _ = db.drop_table::<TestRole>().execute().await;
    let _ = db.drop_table::<TestUser>().execute().await;

    // 创建表
    db.create_table::<TestUser>().execute().await?;
    println!("[TEST] Created TestUser table");
    db.create_table::<TestRole>().execute().await?;
    println!("[TEST] Created TestRole table");

    // 插入测试数据
    db.insert(&TestUser {
        id: 1,
        name: "Alice".to_string(),
        age: 25,
    })
    .execute()
    .await?;
    println!("[TEST] Inserted TestUser 1");
    db.insert(&TestUser {
        id: 2,
        name: "Bob".to_string(),
        age: 30,
    })
    .execute()
    .await?;
    println!("[TEST] Inserted TestUser 2");
    db.insert(&TestUser {
        id: 3,
        name: "Charlie".to_string(),
        age: 35,
    })
    .execute()
    .await?;
    println!("[TEST] Inserted TestUser 3");

    db.insert(&TestRole {
        id: 1,
        user_id: 1,
        role_name: "admin".to_string(),
    })
    .execute()
    .await?;
    db.insert(&TestRole {
        id: 2,
        user_id: 2,
        role_name: "admin".to_string(),
    })
    .execute()
    .await?;
    db.insert(&TestRole {
        id: 3,
        user_id: 3,
        role_name: "user".to_string(),
    })
    .execute()
    .await?;

    // 测试1: 普通的collect为基本类型
    let admin_user_ids: Vec<i32> = db
        .select::<TestRole>()
        .filter(|r| r.role_name.eq("admin"))
        .map_to(|r| r.user_id)
        .collect::<Vec<i32>>()
        .await?;

    println!("Admin user IDs (as i32): {:?}", admin_user_ids);
    assert_eq!(admin_user_ids, vec![1, 2]);

    // 测试2: 使用collect_with转换为Model
    let admin_user_ids_as_model: Vec<UserId> = db
        .select::<TestRole>()
        .filter(|r| r.role_name.eq("admin"))
        .map_to(|r| r.user_id)
        .collect_with(|id| UserId { id })
        .await?;

    println!(
        "Admin user IDs (as UserId Model): {:?}",
        admin_user_ids_as_model
    );
    assert_eq!(admin_user_ids_as_model.len(), 2);
    assert_eq!(admin_user_ids_as_model[0].id, 1);
    assert_eq!(admin_user_ids_as_model[1].id, 2);

    // 测试3: 元组投影
    let role_data: Vec<(i32, String)> = db
        .select::<TestRole>()
        .filter(|r| r.role_name.eq("admin"))
        .map_to(|r| (r.user_id, r.role_name))
        .collect::<Vec<(i32, String)>>()
        .await?;

    println!("Role data (as tuple): {:?}", role_data);
    assert_eq!(role_data.len(), 2);
    assert_eq!(role_data[0], (1, "admin".to_string()));

    println!("\n✅ All tests passed!");

    // 清理测试表
    db.drop_table::<TestRole>().execute().await?;
    db.drop_table::<TestUser>().execute().await?;

    Ok(())
}

test_on_all_dbs_result!(test_collect_with_impl);