Merge pull request diesel-rs#101 from tohou/chrono-time

Implement FromSql and ToSql for `chrono::NaiveTime`

Author: sgrif

diesel/src/types/impls/date_and_time/chrono.rs

@@ -4,19 +4,21 @@ extern crate chrono;
 
 use std::error::Error;
 use std::io::Write;
-use self::chrono::{Duration, NaiveDateTime, NaiveDate};
+use self::chrono::{Duration, NaiveDateTime, NaiveDate, NaiveTime};
 
 use expression::AsExpression;
 use expression::bound::Bound;
 use query_source::Queryable;
-use super::PgTimestamp;
-use types::{self, FromSql, IsNull, Timestamp, ToSql};
+use super::{PgTime, PgTimestamp};
+use types::{self, FromSql, IsNull, Time, Timestamp, ToSql};
 
 expression_impls! {
+    Time -> NaiveTime,
     Timestamp -> NaiveDateTime,
 }
 
 queryable_impls! {
+    Time -> NaiveTime,
     Timestamp -> NaiveDateTime,
 }
 
@@ -45,6 +47,28 @@ impl ToSql<Timestamp> for NaiveDateTime {
     }
 }
 
+fn midnight() -> NaiveTime {
+    NaiveTime::from_hms(0, 0, 0)
+}
+
+impl ToSql<Time> for NaiveTime {
+    fn to_sql<W: Write>(&self, out: &mut W) -> Result<IsNull, Box<Error>> {
+        let duration = *self - midnight();
+        match duration.num_microseconds() {
+            Some(offset) => ToSql::<Time>::to_sql(&PgTime(offset), out),
+            None => unreachable!()
+        }
+    }
+}
+
+impl FromSql<Time> for NaiveTime {
+    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
+        let PgTime(offset) = try!(FromSql::<Time>::from_sql(bytes));
+        let duration = Duration::microseconds(offset);
+        Ok(midnight() + duration)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     extern crate dotenv;
@@ -57,7 +81,7 @@ mod tests {
     use connection::Connection;
     use expression::dsl::{sql, now};
     use prelude::*;
-    use types::Timestamp;
+    use types::{Time, Timestamp};
 
     fn connection() -> Connection {
         dotenv().ok();
@@ -95,4 +119,37 @@ mod tests {
         let query = select(now.at_time_zone("utc").gt(time));
         assert!(query.get_result::<bool>(&connection).unwrap());
     }
+
+    #[test]
+    fn times_of_day_encode_correctly() {
+        let connection = connection();
+
+        let midnight = NaiveTime::from_hms(0, 0, 0);
+        let query = select(sql::<Time>("'00:00:00'::time").eq(midnight));
+        assert!(query.get_result::<bool>(&connection).unwrap());
+
+        let noon = NaiveTime::from_hms(12, 0, 0);
+        let query = select(sql::<Time>("'12:00:00'::time").eq(noon));
+        assert!(query.get_result::<bool>(&connection).unwrap());
+
+        let roughly_half_past_eleven = NaiveTime::from_hms_micro(23, 37, 04, 2200);
+        let query = select(sql::<Time>("'23:37:04.002200'::time").eq(roughly_half_past_eleven));
+        assert!(query.get_result::<bool>(&connection).unwrap());
+    }
+
+    #[test]
+    fn times_of_day_decode_correctly() {
+        let connection = connection();
+        let midnight = NaiveTime::from_hms(0, 0, 0);
+        let query = select(sql::<Time>("'00:00:00'::time"));
+        assert_eq!(Ok(midnight), query.get_result::<NaiveTime>(&connection));
+
+        let noon = NaiveTime::from_hms(12, 0, 0);
+        let query = select(sql::<Time>("'12:00:00'::time"));
+        assert_eq!(Ok(noon), query.get_result::<NaiveTime>(&connection));
+
+        let roughly_half_past_eleven = NaiveTime::from_hms_micro(23, 37, 04, 2200);
+        let query = select(sql::<Time>("'23:37:04.002200'::time"));
+        assert_eq!(Ok(roughly_half_past_eleven), query.get_result::<NaiveTime>(&connection));
+    }
 }

diesel_tests/tests/types_roundtrip.rs

@@ -1,7 +1,7 @@
 extern crate chrono;
 
 pub use quickcheck::quickcheck;
-use self::chrono::NaiveDateTime;
+use self::chrono::{NaiveDateTime, NaiveTime};
 
 pub use schema::connection;
 pub use diesel::*;
@@ -80,11 +80,16 @@ test_round_trip!(timestamp_roundtrips, Timestamp, PgTimestamp);
 test_round_trip!(interval_roundtrips, Interval, PgInterval);
 test_round_trip!(numeric_roundtrips, Numeric, PgNumeric);
 test_round_trip!(naive_datetime_roundtrips, Timestamp, (i64, u32), mk_naive_datetime);
+test_round_trip!(naive_time_roundtrips, Time, (u32, u32), mk_naive_time);
 
 fn mk_naive_datetime(data: (i64, u32)) -> NaiveDateTime {
     NaiveDateTime::from_timestamp(data.0, data.1 / 1000)
 }
 
+fn mk_naive_time(data: (u32, u32)) -> NaiveTime {
+    NaiveTime::from_num_seconds_from_midnight(data.0, data.1 / 1000)
+}
+
 #[cfg(feature = "unstable")]
 mod unstable_types {
     use super::*;