bottle-orm 0.5.9

A lightweight and simple ORM for Rust built on top of sqlx
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


use bottle_orm::{Database, Model};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Model, Debug, Clone, Serialize, Deserialize, PartialEq)]
struct NullableUser {
    #[orm(primary_key)]
    id: Uuid,
    username: String,
    role: Option<String>,
}

#[tokio::test]
async fn test_update_to_null() -> Result<(), Box<dyn std::error::Error>> {
    let db = Database::builder().max_connections(1).connect("sqlite::memory:").await?;
    db.sync_table::<NullableUser>().await?;

    let user_id = Uuid::new_v4();
    let user = NullableUser {
        id: user_id,
        username: "test_user".to_string(),
        role: Some("admin".to_string()),
    };

    // Insert user with role
    db.model::<NullableUser>().insert(&user).await?;

    // Verify role is set
    let saved_user: NullableUser = db.model::<NullableUser>()
        .equals("id", user_id.to_string())
        .first()
        .await?;
    assert_eq!(saved_user.role, Some("admin".to_string()));

    // Update role to None (NULL)
    db.model::<NullableUser>()
        .equals("id", user_id.to_string())
        .update("role", None::<String>)
        .await?;

    // Verify role is now NULL
    let updated_user: NullableUser = db.model::<NullableUser>()
        .equals("id", user_id.to_string())
        .first()
        .await?;
    assert_eq!(updated_user.role, None);

    // Update role back to Some
    db.model::<NullableUser>()
        .equals("id", user_id.to_string())
        .update("role", Some("editor".to_string()))
        .await?;

    // Verify role is updated
    let updated_user2: NullableUser = db.model::<NullableUser>()
        .equals("id", user_id.to_string())
        .first()
        .await?;
    assert_eq!(updated_user2.role, Some("editor".to_string()));

    // Test updating via model updates()
    let mut user_to_null = updated_user2.clone();
    user_to_null.role = None;
    db.model::<NullableUser>()
        .equals("id", user_id.to_string())
        .updates(&user_to_null)
        .await?;

    // Verify role is NULL again
    let final_user: NullableUser = db.model::<NullableUser>()
        .equals("id", user_id.to_string())
        .first()
        .await?;
    assert_eq!(final_user.role, None);

    // Test insert with None
    let user_no_role_id = Uuid::new_v4();
    let user_no_role = NullableUser {
        id: user_no_role_id,
        username: "no_role_user".to_string(),
        role: None,
    };
    db.model::<NullableUser>().insert(&user_no_role).await?;

    let saved_no_role: NullableUser = db.model::<NullableUser>()
        .equals("id", user_no_role_id.to_string())
        .first()
        .await?;
    assert_eq!(saved_no_role.role, None);

    println!("Update to NULL test passed!");
    Ok(())
}