microrm 0.6.3

Lightweight ORM using sqlite as a backend
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

use crate::{
    db::{StatementContext, StatementRow},
    schema::{
        entity::{Entity, EntityID, EntityPartList},
        Stored,
    },
    DBResult, Error,
};

pub trait IDContainer<T: Entity>: 'static + IntoIterator<Item = T::ID> {
    fn assemble_from(ctx: StatementContext<'_>) -> DBResult<Self>
    where
        Self: Sized;
}

pub trait OutputContainer<T: Entity>: 'static + IntoIterator<Item = Stored<T>> {
    type IDContainer: IDContainer<T>;
    type WithReplacedEntity<N: Entity>: OutputContainer<N>;
    fn assemble_from(stmt: StatementContext<'_>) -> DBResult<Self>
    where
        Self: Sized;
}

fn assemble_id<T: Entity>(row: StatementRow) -> T::ID {
    <T::ID>::from_raw(row.read::<i64>(0).expect("couldn't read ID"))
}

fn assemble_single<T: Entity>(row: &mut StatementRow) -> Stored<T> {
    let id = row.read::<i64>(0).expect("couldn't read ID");
    let datum_list = <T::Parts>::build_datum_list(row).expect("couldn't build datum list");
    Stored::new(T::ID::from_raw(id), T::build(datum_list))
}

impl<T: Entity> IDContainer<T> for Option<T::ID> {
    fn assemble_from(ctx: StatementContext<'_>) -> DBResult<Self>
    where
        Self: Sized,
    {
        Ok(ctx.run()?.map(assemble_id::<T>))
    }
}

impl<T: Entity> OutputContainer<T> for Option<Stored<T>> {
    type IDContainer = Option<T::ID>;
    type WithReplacedEntity<N: Entity> = Option<Stored<N>>;

    fn assemble_from(ctx: StatementContext<'_>) -> DBResult<Self>
    where
        Self: Sized,
    {
        Ok(ctx.run()?.map(|mut r| assemble_single(&mut r)))
    }
}

impl<T: Entity> IDContainer<T> for Vec<T::ID> {
    fn assemble_from(ctx: StatementContext<'_>) -> DBResult<Self>
    where
        Self: Sized,
    {
        ctx.iter()
            .map(|r| r.map(assemble_id::<T>))
            .collect::<Result<Vec<_>, Error>>()
    }
}

impl<T: Entity> OutputContainer<T> for Vec<Stored<T>> {
    type IDContainer = Vec<T::ID>;
    type WithReplacedEntity<N: Entity> = Vec<Stored<N>>;

    fn assemble_from(ctx: StatementContext<'_>) -> DBResult<Self>
    where
        Self: Sized,
    {
        ctx.iter()
            .map(|r| r.map(|mut s| assemble_single(&mut s)))
            .collect::<Result<Vec<_>, Error>>()
    }
}