crash_orm 0.7.2

A simple, typed ORM for Postgres
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

#[allow(missing_docs)]
macro_rules! default_relation_function {
    ($rel_type:tt) => {
        /// Creates the relation with a given id.
        pub const fn new(target_id: P) -> $rel_type<T, P> {
            Self {
                _p: PhantomData,
                target_id,
            }
        }

        /// Creates the relation from an entity.
        ///
        /// This utilizes the [Entity::get_primary] function.
        pub fn from(entity: &impl PrimaryKeyEntity<P>) -> crate::Result<$rel_type<T, P>> {
            let id = entity.get_primary();
            Ok(Self::new(id))
        }
    };
}

#[allow(missing_docs)]
macro_rules! sql_impl_for_relation {
    ($rel_type:tt) => {
        impl<T: PrimaryKeyEntity<P>, P: ColumnType> tokio_postgres::types::ToSql for $rel_type<T, P> {
            fn to_sql(
                &self,
                ty: &tokio_postgres::types::Type,
                out: &mut postgres::types::private::BytesMut,
            ) -> Result<tokio_postgres::types::IsNull, Box<dyn std::error::Error + Sync + Send>>
            where
                Self: Sized,
            {
                self.target_id.to_sql(ty, out)
            }

            fn accepts(ty: &tokio_postgres::types::Type) -> bool
            where
                Self: Sized,
            {
                <P as tokio_postgres::types::ToSql>::accepts(ty)
            }

            fn to_sql_checked(
                &self,
                ty: &tokio_postgres::types::Type,
                out: &mut postgres::types::private::BytesMut,
            ) -> Result<tokio_postgres::types::IsNull, Box<dyn std::error::Error + Sync + Send>> {
                self.target_id.to_sql_checked(ty, out)
            }
        }

        impl<'a, T: PrimaryKeyEntity<P>, P: ColumnType> tokio_postgres::types::FromSql<'a> for $rel_type<T, P> {
            fn from_sql(ty: &tokio_postgres::types::Type, raw: &'a [u8]) -> Result<Self, Box<dyn std::error::Error + Sync + Send>> {
                let id = P::from_sql(ty, raw)?;
                Ok($rel_type::<T, P>::new(id))
            }

            fn accepts(ty: &tokio_postgres::types::Type) -> bool {
                <P as tokio_postgres::types::FromSql>::accepts(ty)
            }
        }

        #[cfg(feature = "serialize")]
        impl<'a, T: PrimaryKeyEntity<P>, P: ColumnType + serde::Deserialize<'a>> serde::Deserialize<'a> for $rel_type<T, P> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: serde::Deserializer<'a>
            {
                P::deserialize(deserializer).map(|v| $rel_type::new(v))
            }
        }

        #[cfg(feature = "serialize")]
        impl<T: PrimaryKeyEntity<P>, P: ColumnType + serde::Serialize> serde::Serialize for $rel_type<T, P> {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: serde::Serializer
            {
                P::serialize(&self.target_id, serializer)
            }
        }
    };
}

pub(super) use default_relation_function;
pub(super) use sql_impl_for_relation;