sea-orm 2.0.0

🐚 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
80
81
82

#![allow(unused_imports, dead_code)]

pub mod common;

pub use common::{TestContext, features::*, setup::*};
use pretty_assertions::assert_eq;
use sea_orm::TryInsertResult;
use sea_orm::entity::prelude::*;
use sea_orm::{Set, sea_query::OnConflict};

#[sea_orm_macros::test]
async fn main() -> Result<(), DbErr> {
    let ctx = TestContext::new("upsert_tests").await;
    create_insert_default_table(&ctx.db).await?;
    create_insert_default(&ctx.db).await?;
    ctx.delete().await;

    Ok(())
}

pub async fn create_insert_default(db: &DatabaseConnection) -> Result<(), DbErr> {
    use insert_default::*;

    let res = Entity::insert_many::<ActiveModel, _>([]).exec(db).await;

    assert_eq!(res?.last_insert_id, None);

    let res = Entity::insert_many([ActiveModel { id: Set(1) }, ActiveModel { id: Set(2) }])
        .exec(db)
        .await;

    assert_eq!(res?.last_insert_id, Some(2));

    let on_conflict = OnConflict::column(Column::Id)
        .do_nothing_on([Column::Id])
        .to_owned();

    let res = Entity::insert_many([
        ActiveModel { id: Set(1) },
        ActiveModel { id: Set(2) },
        ActiveModel { id: Set(3) },
    ])
    .on_conflict(on_conflict.clone())
    .exec(db)
    .await;

    assert_eq!(res?.last_insert_id, Some(3));

    let res = Entity::insert_many([
        ActiveModel { id: Set(1) },
        ActiveModel { id: Set(2) },
        ActiveModel { id: Set(3) },
        ActiveModel { id: Set(4) },
    ])
    .on_conflict(on_conflict.clone())
    .exec(db)
    .await;

    assert_eq!(res?.last_insert_id, Some(4));

    let res = Entity::insert_many([ActiveModel { id: Set(3) }, ActiveModel { id: Set(4) }])
        .exec(db)
        .await;

    assert!(matches!(res, Err(DbErr::Query(_) | DbErr::Exec(_))));

    let res = Entity::insert_many([ActiveModel { id: Set(3) }, ActiveModel { id: Set(4) }])
        .on_conflict(on_conflict.clone())
        .exec(db)
        .await;

    assert!(matches!(res, Err(DbErr::RecordNotInserted)));

    let res = Entity::insert_many([ActiveModel { id: Set(3) }, ActiveModel { id: Set(4) }])
        .on_conflict_do_nothing_on([Column::Id])
        .exec(db)
        .await;

    assert!(matches!(res, Ok(TryInsertResult::Conflicted)));

    Ok(())
}