retrom-codegen 0.7.51

Code generation for Retrom
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

use std::time::{Duration, SystemTime, UNIX_EPOCH};

use diesel::sql_types::{self, SqlType};
use diesel::{
    deserialize::{FromSql, FromSqlRow},
    expression::AsExpression,
    pg::PgValue,
    serialize::{Output, ToSql},
};

fn pg_epoch() -> SystemTime {
    let thirty_years = Duration::from_secs(946_684_800);
    UNIX_EPOCH + thirty_years
}

#[derive(
    Clone,
    Eq,
    Hash,
    Copy,
    PartialEq,
    PartialOrd,
    Ord,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    SqlType,
    AsExpression,
    FromSqlRow,
)]
#[diesel(postgres_type(oid = 1114, array_oid = 1115))]
#[diesel(sql_type = diesel::sql_types::Timestamp)]
#[diesel(sql_type = diesel::sql_types::Timestamptz)]
pub struct Timestamp {
    #[prost(int64, tag = "1")]
    pub seconds: i64,
    #[prost(int32, tag = "2")]
    pub nanos: i32,
}

impl Timestamp {
    pub fn elapsed_since(&self, earlier: &Timestamp) -> Option<Duration> {
        let self_duration = Duration::new(self.seconds as u64, self.nanos as u32);
        let earlier_duration = Duration::new(earlier.seconds as u64, earlier.nanos as u32);

        self_duration.checked_sub(earlier_duration)
    }
}

impl TryFrom<Timestamp> for prost_types::Timestamp {
    type Error = prost::DecodeError;

    fn try_from(value: Timestamp) -> Result<Self, Self::Error> {
        Ok(prost_types::Timestamp {
            seconds: value.seconds,
            nanos: value.nanos,
        })
    }
}

impl From<prost_types::Timestamp> for Timestamp {
    fn from(value: prost_types::Timestamp) -> Self {
        Timestamp {
            seconds: value.seconds,
            nanos: value.nanos,
        }
    }
}

impl From<std::time::SystemTime> for Timestamp {
    fn from(time: std::time::SystemTime) -> Self {
        prost_types::Timestamp::from(time).into()
    }
}

impl ToSql<sql_types::Timestamp, diesel::pg::Pg> for Timestamp {
    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, diesel::pg::Pg>) -> diesel::serialize::Result {
        let thirty_years_seconds = 946_684_800;
        let micros = (self.seconds - thirty_years_seconds) * 1_000_000 + self.nanos as i64 / 1_000;

        ToSql::<sql_types::BigInt, diesel::pg::Pg>::to_sql(&micros, &mut out.reborrow())
    }
}

impl ToSql<sql_types::Timestamptz, diesel::pg::Pg> for Timestamp {
    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, diesel::pg::Pg>) -> diesel::serialize::Result {
        ToSql::<sql_types::Timestamp, diesel::pg::Pg>::to_sql(self, out)
    }
}

impl FromSql<sql_types::Timestamp, diesel::pg::Pg> for Timestamp {
    fn from_sql(bytes: PgValue<'_>) -> diesel::deserialize::Result<Self> {
        let micros = i64::from_sql(bytes)?;

        let pg_timestamp = match micros < 0 {
            true => pg_epoch() - Duration::from_micros(micros.unsigned_abs()),
            false => pg_epoch() + Duration::from_micros(micros.unsigned_abs()),
        };

        Ok(pg_timestamp.into())
    }
}

impl FromSql<sql_types::Timestamptz, diesel::pg::Pg> for Timestamp {
    fn from_sql(bytes: PgValue<'_>) -> diesel::deserialize::Result<Self> {
        FromSql::<sql_types::Timestamp, diesel::pg::Pg>::from_sql(bytes)
    }
}