sea-orm-sync 2.0.0-rc.40

🐚 The sync version of SeaORM
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
136

//! `SeaORM` Entity, @generated by sea-orm-codegen 2.0.0-rc.9

use sea_orm::entity::prelude::*;

#[sea_orm::model]
#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
#[sea_orm(table_name = "cake")]
pub struct Model {
    #[sea_orm(primary_key)]
    pub id: i32,
    #[sea_orm(unique)]
    pub name: String,
    #[sea_orm(column_type = "Decimal(Some((16, 4)))")]
    pub price: Decimal,
    pub bakery_id: Option<i32>,
    pub gluten_free: bool,
    pub serial: Uuid,
    #[sea_orm(belongs_to, from = "BakeryId", to = "Id")]
    pub bakery: HasOne<super::bakery::Entity>,
    #[sea_orm(has_many)]
    pub lineitems: HasMany<super::lineitem::Entity>,
    #[sea_orm(has_many, via = "cakes_bakers")]
    pub bakers: HasMany<super::baker::Entity>,
}

impl ActiveModelBehavior for ActiveModel {
    fn new() -> Self {
        use sea_orm::Set;
        Self {
            serial: Set(Uuid::new_v4()),
            ..ActiveModelTrait::default()
        }
    }
}

/* // Following will be generated

pub struct EntityLoader {
    select: sea_orm::Select<Entity>,
    with: EntityLoaderWith,
}

#[derive(Debug, Default)]
struct EntityLoaderWith {
    bakery: bool,
    baker: bool,
}

impl sea_orm::QueryFilter for EntityLoader {
    type QueryStatement = <sea_orm::Select<Entity> as sea_orm::QueryFilter>::QueryStatement;

    fn query(&mut self) -> &mut Self::QueryStatement {
        sea_orm::QueryFilter::query(&mut self.select)
    }
}

impl sea_orm::QueryOrder for EntityLoader {
    type QueryStatement = <sea_orm::Select<Entity> as sea_orm::QueryOrder>::QueryStatement;

    fn query(&mut self) -> &mut Self::QueryStatement {
        sea_orm::QueryOrder::query(&mut self.select)
    }
}

impl sea_orm::compound::EntityLoaderTrait<Entity> for EntityLoader {}

impl Entity {
    pub fn load() -> EntityLoader {
        EntityLoader {
            select: Entity::find(),
            with: Default::default(),
        }
    }
}

impl EntityLoader {
    pub fn one<C: sea_orm::ConnectionTrait>(
        mut self,
        db: &C,
    ) -> Result<Option<Model>, DbErr> {
        use sea_orm::QuerySelect;

        self.select = self.select.limit(1);
        Ok(self.all(db)?.into_iter().next())
    }

    pub fn with<R>(mut self, entity: R) -> Self
    where
        R: EntityTrait,
        Entity: Related<R>,
    {
        if entity.table_ref() == super::bakery::Entity.table_ref() {
            self.with.bakery = true;
        }
        if entity.table_ref() == super::baker::Entity.table_ref() {
            self.with.baker = true;
        }
        self
    }

    pub fn load<C: sea_orm::ConnectionTrait>(Vec<Model>, with: &EntityLoaderWith, nest: &EntityLoaderNest, db: &C) -> Result<Vec<Model>, DbErr> {
        if self.with.baker {
            let bakers = cakes.load_many(super::baker::Entity, db)?;
            super::baker::EntityLoader::load_nest_nest(bakers, &nest.baker)?;

            for (cake, bakers) in cakes.iter_mut().zip(bakers) {
                cake.bakers.set(bakers);
            }
        }
    }

    pub fn all<C: sea_orm::ConnectionTrait>(mut self, db: &C) -> Result<Vec<Model>, DbErr> {
        let select = if self.with.bakery {
            self.with.bakery = false;
            self.select.find_also(Entity, super::bakery::Entity)
        } else {
            // select also but without join
            self.select.select_also_fake(super::bakery::Entity)
        };

        let models = select.all(db)?;

        let mut cakes = Vec::new();

        for (mut cake, bakery) in models {
            cake.bakery.set(bakery);
            cakes.push(cake);
        }

        let cakes = Self::load(cakes, &self.with, db)?;

        Ok(cakes)
    }
}

*/