Add support for time 0.3

postgres-types/Cargo.toml

@@ -22,6 +22,7 @@ with-geo-types-0_7 = ["geo-types-0_7"]
 with-serde_json-1 = ["serde-1", "serde_json-1"]
 with-uuid-0_8 = ["uuid-08"]
 with-time-0_2 = ["time-02"]
+with-time-0_3 = ["time-03"]
 
 [dependencies]
 bytes = "1.0"
@@ -40,3 +41,4 @@ serde-1 = { version = "1.0", package = "serde", optional = true }
 serde_json-1 = { version = "1.0", package = "serde_json", optional = true }
 uuid-08 = { version = "0.8", package = "uuid", optional = true }
 time-02 = { version = "0.2", package = "time", optional = true }
+time-03 = { version = "0.3", package = "time", default-features = false, optional = true }

postgres-types/src/lib.rs

@@ -209,6 +209,8 @@ mod geo_types_07;
 mod serde_json_1;
 #[cfg(feature = "with-time-0_2")]
 mod time_02;
+#[cfg(feature = "with-time-0_3")]
+mod time_03;
 #[cfg(feature = "with-uuid-0_8")]
 mod uuid_08;
 

postgres-types/src/time_03.rs

@@ -0,0 +1,108 @@
+use bytes::BytesMut;
+use postgres_protocol::types;
+use std::convert::TryFrom;
+use std::error::Error;
+use time_03::{Date, Duration, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};
+
+use crate::{FromSql, IsNull, ToSql, Type};
+
+fn base() -> PrimitiveDateTime {
+    PrimitiveDateTime::new(Date::from_ordinal_date(2000, 1).unwrap(), Time::MIDNIGHT)
+}
+
+impl<'a> FromSql<'a> for PrimitiveDateTime {
+    fn from_sql(_: &Type, raw: &[u8]) -> Result<PrimitiveDateTime, Box<dyn Error + Sync + Send>> {
+        let t = types::timestamp_from_sql(raw)?;
+        Ok(base() + Duration::microseconds(t))
+    }
+
+    accepts!(TIMESTAMP);
+}
+
+impl ToSql for PrimitiveDateTime {
+    fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+        let time = match i64::try_from((*self - base()).whole_microseconds()) {
+            Ok(time) => time,
+            Err(_) => return Err("value too large to transmit".into()),
+        };
+        types::timestamp_to_sql(time, w);
+        Ok(IsNull::No)
+    }
+
+    accepts!(TIMESTAMP);
+    to_sql_checked!();
+}
+
+impl<'a> FromSql<'a> for OffsetDateTime {
+    fn from_sql(type_: &Type, raw: &[u8]) -> Result<OffsetDateTime, Box<dyn Error + Sync + Send>> {
+        let primitive = PrimitiveDateTime::from_sql(type_, raw)?;
+        Ok(primitive.assume_utc())
+    }
+
+    accepts!(TIMESTAMPTZ);
+}
+
+impl ToSql for OffsetDateTime {
+    fn to_sql(
+        &self,
+        type_: &Type,
+        w: &mut BytesMut,
+    ) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+        let utc_datetime = self.to_offset(UtcOffset::UTC);
+        let date = utc_datetime.date();
+        let time = utc_datetime.time();
+        let primitive = PrimitiveDateTime::new(date, time);
+        primitive.to_sql(type_, w)
+    }
+
+    accepts!(TIMESTAMPTZ);
+    to_sql_checked!();
+}
+
+impl<'a> FromSql<'a> for Date {
+    fn from_sql(_: &Type, raw: &[u8]) -> Result<Date, Box<dyn Error + Sync + Send>> {
+        let jd = types::date_from_sql(raw)?;
+        Ok(base().date() + Duration::days(i64::from(jd)))
+    }
+
+    accepts!(DATE);
+}
+
+impl ToSql for Date {
+    fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+        let jd = (*self - base().date()).whole_days();
+        if jd > i64::from(i32::max_value()) || jd < i64::from(i32::min_value()) {
+            return Err("value too large to transmit".into());
+        }
+
+        types::date_to_sql(jd as i32, w);
+        Ok(IsNull::No)
+    }
+
+    accepts!(DATE);
+    to_sql_checked!();
+}
+
+impl<'a> FromSql<'a> for Time {
+    fn from_sql(_: &Type, raw: &[u8]) -> Result<Time, Box<dyn Error + Sync + Send>> {
+        let usec = types::time_from_sql(raw)?;
+        Ok(Time::MIDNIGHT + Duration::microseconds(usec))
+    }
+
+    accepts!(TIME);
+}
+
+impl ToSql for Time {
+    fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+        let delta = *self - Time::MIDNIGHT;
+        let time = match i64::try_from(delta.whole_microseconds()) {
+            Ok(time) => time,
+            Err(_) => return Err("value too large to transmit".into()),
+        };
+        types::time_to_sql(time, w);
+        Ok(IsNull::No)
+    }
+
+    accepts!(TIME);
+    to_sql_checked!();
+}