sea-orm 0.5.0-rc.1

🐚 An async & dynamic ORM for Rust
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

pub use super::*;
use serde::{Deserialize, Serialize};

pub async fn test_create_baker(db: &DbConn) {
    let seaside_bakery = bakery::ActiveModel {
        name: Set("SeaSide Bakery".to_owned()),
        profit_margin: Set(10.4),
        ..Default::default()
    };
    let bakery_insert_res = Bakery::insert(seaside_bakery)
        .exec(db)
        .await
        .expect("could not insert bakery");

    #[derive(Serialize, Deserialize)]
    struct ContactDetails {
        mobile: String,
        home: String,
        address: String,
    }

    let baker_bob_contact = ContactDetails {
        mobile: "+61424000000".to_owned(),
        home: "0395555555".to_owned(),
        address: "12 Test St, Testville, Vic, Australia".to_owned(),
    };
    let baker_bob = baker::ActiveModel {
        name: Set("Baker Bob".to_owned()),
        contact_details: Set(serde_json::json!(baker_bob_contact)),
        bakery_id: Set(Some(bakery_insert_res.last_insert_id as i32)),
        ..Default::default()
    };
    let res = Baker::insert(baker_bob)
        .exec(db)
        .await
        .expect("could not insert baker");

    let baker: Option<baker::Model> = Baker::find_by_id(res.last_insert_id)
        .one(db)
        .await
        .expect("could not find baker");

    assert!(baker.is_some());
    let baker_model = baker.unwrap();
    assert_eq!(baker_model.name, "Baker Bob");
    assert_eq!(
        baker_model.contact_details["mobile"],
        baker_bob_contact.mobile
    );
    assert_eq!(baker_model.contact_details["home"], baker_bob_contact.home);
    assert_eq!(
        baker_model.contact_details["address"],
        baker_bob_contact.address
    );
    assert_eq!(
        baker_model
            .find_related(Bakery)
            .one(db)
            .await
            .expect("Bakery not found")
            .unwrap()
            .name,
        "SeaSide Bakery"
    );

    let bakery: Option<bakery::Model> = Bakery::find_by_id(bakery_insert_res.last_insert_id)
        .one(db)
        .await
        .unwrap();

    let related_bakers: Vec<baker::Model> = bakery
        .unwrap()
        .find_related(Baker)
        .all(db)
        .await
        .expect("could not find related bakers");
    assert_eq!(related_bakers.len(), 1);
    assert_eq!(related_bakers[0].name, "Baker Bob")
}