toasty 0.7.0

An async ORM for Rust supporting SQL and NoSQL databases
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

use super::{Deferred, Load, Model, Register, RelationManyField};

use toasty_core::schema::Name;
use toasty_core::schema::app::{self, FieldId, FieldTy, ModelId};
use toasty_core::stmt;

impl<M: Model> RelationManyField for Vec<M> {
    type Model = M;

    const DEFERRED: bool = false;

    fn reload(target: &mut Self, value: stmt::Value) -> crate::Result<()> {
        <Self as Load>::reload(target, value)
    }

    fn many_relation_field_ty(
        singular: Name,
        pair: Option<FieldId>,
        via: Option<stmt::Path>,
    ) -> FieldTy {
        many_relation_field_ty::<M>(singular, pair, via)
    }
}

impl<M: Model> RelationManyField for Deferred<Vec<M>> {
    type Model = M;

    const DEFERRED: bool = true;

    fn reload(target: &mut Self, _value: stmt::Value) -> crate::Result<()> {
        target.unload();
        Ok(())
    }

    fn many_relation_field_ty(
        singular: Name,
        pair: Option<FieldId>,
        via: Option<stmt::Path>,
    ) -> FieldTy {
        many_relation_field_ty::<M>(singular, pair, via)
    }
}

fn many_relation_field_ty<M: Model>(
    singular: Name,
    pair: Option<FieldId>,
    via: Option<stmt::Path>,
) -> FieldTy {
    let target = <M as Register>::id();
    let expr_ty = stmt::Type::List(Box::new(stmt::Type::Model(target)));
    let cardinality = app::Cardinality::Many { singular };

    match via {
        Some(path) => FieldTy::Via(app::Via::new(target, expr_ty, cardinality, path)),
        None => FieldTy::Has(app::Has {
            target,
            expr_ty,
            cardinality,
            pair_id: pair.unwrap_or(FieldId {
                model: ModelId(usize::MAX),
                index: usize::MAX,
            }),
        }),
    }
}