rbdc 4.9.10

The Rust SQL Toolkit and ORM Library. An async, pure Rust SQL crate featuring compile-time Dynamic SQL
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 crate::{DateTime, Error};
use rbs::Value;
use serde::Deserializer;
use std::fmt::{Debug, Display, Formatter};
use std::str::FromStr;

/// Timestamp(timestamp_millis:u64)
#[derive(serde::Serialize, Clone, Eq, PartialEq, Hash)]
#[serde(rename = "Timestamp")]
pub struct Timestamp(pub i64);

impl Timestamp {
    #[deprecated(note = "please use utc()")]
    pub fn now() -> Self {
        Self(fastdate::DateTime::utc().unix_timestamp_millis())
    }
    /// utc time
    pub fn utc() -> Self {
        Self(fastdate::DateTime::utc().unix_timestamp_millis())
    }
}

impl<'de> serde::Deserialize<'de> for Timestamp {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        use serde::de::Error;
        match Value::deserialize(deserializer)?.as_i64() {
            None => Err(Error::custom("warn type decode Json")),
            Some(v) => Ok(Self(v)),
        }
    }
}

impl Display for Timestamp {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl Debug for Timestamp {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "Timestamp({})", self.0)
    }
}

impl From<Timestamp> for Value {
    fn from(arg: Timestamp) -> Self {
        Value::Ext("Timestamp", Box::new(Value::I64(arg.0)))
    }
}

impl FromStr for Timestamp {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(Timestamp(i64::from_str(s)?))
    }
}

impl From<Timestamp> for fastdate::DateTime {
    fn from(value: Timestamp) -> Self {
        fastdate::DateTime::from_timestamp_millis(value.0 as i64)
    }
}

impl Default for Timestamp {
    fn default() -> Self {
        Timestamp(0)
    }
}

impl From<DateTime> for Timestamp {
    fn from(value: DateTime) -> Self {
        Self(value.unix_timestamp_millis())
    }
}

impl Into<DateTime> for Timestamp {
    fn into(self) -> DateTime {
        DateTime::from_timestamp_millis(self.0)
    }
}

#[cfg(test)]
mod test {
    use crate::DateTime;
    use crate::timestamp::Timestamp;
    use rbs::Value;

    #[test]
    fn test_from_timestamp() {
        let v = Timestamp::utc();
        let dt: DateTime = v.into();
        println!("{}", dt);
    }

    #[test]
    fn test_ser_de() {
        let dt = Timestamp::utc();
        let v = serde_json::to_value(&dt).unwrap();
        let new_dt: Timestamp = serde_json::from_value(v).unwrap();
        assert_eq!(new_dt, dt);
    }

    #[test]
    fn test_decode_timestamp_u64() {
        assert_eq!(Timestamp(1), rbs::from_value(Value::U64(1)).unwrap());
    }

    #[test]
    fn test_decode_timestamp_ext() {
        assert_eq!(
            Timestamp(1),
            rbs::from_value(Value::Ext("Timestamp", Box::new(Value::U64(1)))).unwrap()
        );
    }
}