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
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

use toasty::Deferred;
use toasty::schema::{
    self, CreateMeta, Load, Model, ModelSet, Register, RelationManyField, RelationOneField,
};
use toasty::stmt::{Expr, Insert, IntoExpr, IntoInsert, Path};
use toasty_core::stmt::{self, Value};

#[derive(Debug, PartialEq)]
struct Dummy {
    id: i64,
}

#[derive(Default)]
struct DummyCreate;

impl Load for Dummy {
    type Output = Self;

    fn ty() -> stmt::Type {
        stmt::Type::Model(Self::id())
    }

    fn load(value: Value) -> toasty::Result<Self> {
        let Value::Record(mut record) = value else {
            return Err(toasty_core::Error::type_conversion(value, "Dummy"));
        };

        let id = record[0].take();
        let Value::I64(id) = id else {
            return Err(toasty_core::Error::type_conversion(id, "Dummy::id"));
        };

        Ok(Self { id })
    }
}

impl Register for Dummy {
    fn id() -> schema::app::ModelId {
        schema::app::ModelId(usize::MAX)
    }

    fn schema() -> schema::app::Model {
        panic!("not needed for relation lazy-slot decode tests")
    }

    fn register(_model_set: &mut ModelSet) {}
}

impl Model for Dummy {
    type Query = ();
    type Create = DummyCreate;
    type Update<'a> = ();
    type UpdateQuery = ();
    type Path<Origin> = Path<Origin, Self>;
    type PrimaryKey = i64;
    type Many = ();
    type ViaMany = ();
    type ManyField<Origin> = ();
    type One = ();
    type ViaOne = ();
    type OneField<Origin> = ();
    type OptionOne = ();
    type ViaOptionOne = ();

    const CREATE_META: CreateMeta = CreateMeta {
        fields: &[],
        model_name: "Dummy",
    };

    fn new_path<Origin>(path: Path<Origin, Self>) -> Self::Path<Origin> {
        path
    }

    fn new_many_field<Origin>(_path: Path<Origin, toasty::stmt::List<Self>>) {}

    fn field_name_to_id(_name: &str) -> schema::app::FieldId {
        panic!("not needed for relation lazy-slot decode tests")
    }

    fn find_by_primary_key(_id: Expr<Self::PrimaryKey>) -> Self::Query {}
}

impl IntoInsert for DummyCreate {
    type Model = Dummy;

    fn into_insert(self) -> Insert<Self::Model> {
        panic!("not needed for relation lazy-slot decode tests")
    }
}

impl IntoExpr<Dummy> for DummyCreate {
    fn into_expr(self) -> Expr<Dummy> {
        panic!("not needed for relation lazy-slot decode tests")
    }

    fn by_ref(&self) -> Expr<Dummy> {
        panic!("not needed for relation lazy-slot decode tests")
    }
}

fn assert_has_many_field<F: RelationManyField<Model = Dummy>>() {}
fn assert_has_one_field<F: RelationOneField<Model = Dummy>>() {}
fn assert_belongs_to_field<F: RelationOneField<Model = Dummy>>() {}

#[test]
fn deferred_relation_field_shapes_are_supported() {
    assert_has_many_field::<Vec<Dummy>>();
    assert_has_many_field::<Deferred<Vec<Dummy>>>();

    assert_has_one_field::<Dummy>();
    assert_has_one_field::<Option<Dummy>>();
    assert_has_one_field::<Deferred<Dummy>>();
    assert_has_one_field::<Deferred<Option<Dummy>>>();

    assert_belongs_to_field::<Dummy>();
    assert_belongs_to_field::<Option<Dummy>>();
    assert_belongs_to_field::<Deferred<Dummy>>();
    assert_belongs_to_field::<Deferred<Option<Dummy>>>();
}