Add support for the PG time type

I'm actually working on interval support, and being able to do things
like `datetime_col + 90.days()`. Interval turns out to actually be a
more complex type than I expected, and the first 8 bits of it are
literally a time value, so I'm adding this piece separately.

Author: sgrif

src/types/impls/date_and_time.rs

@@ -13,9 +13,16 @@ pub struct PgTimestamp(pub i64);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct PgDate(pub i32);
 
+/// Time is represented in Postgres as a 64 bit signed integer representing the number of
+/// microseconds since midnight. This struct is a dumb wrapper type, meant only to indicate the
+/// integer's meaning.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct PgTime(pub i64);
+
 primitive_impls! {
     Timestamp -> (PgTimestamp, 1114),
     Date -> (PgDate, 1082),
+    Time -> (PgTime, 1083),
 }
 
 impl ToSql<types::Timestamp> for PgTimestamp {
@@ -43,3 +50,16 @@ impl FromSql<types::Date> for PgDate {
             .map(PgDate)
     }
 }
+
+impl ToSql<types::Time> for PgTime {
+    fn to_sql<W: Write>(&self, out: &mut W) -> Result<IsNull, Box<Error>> {
+        ToSql::<types::BigInt>::to_sql(&self.0, out)
+    }
+}
+
+impl FromSql<types::Time> for PgTime {
+    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
+        FromSql::<types::BigInt>::from_sql(bytes)
+            .map(PgTime)
+    }
+}

src/types/mod.rs

@@ -2,7 +2,7 @@ mod ord;
 mod impls;
 
 pub mod structs {
-    pub use super::impls::date_and_time::{PgTimestamp, PgDate};
+    pub use super::impls::date_and_time::{PgTimestamp, PgDate, PgTime};
 }
 
 pub use self::ord::SqlOrd;
@@ -30,6 +30,7 @@ pub type BigSerial = BigInt;
 #[derive(Clone, Copy)] pub struct Binary;
 
 #[derive(Clone, Copy)] pub struct Date;
+#[derive(Clone, Copy)] pub struct Time;
 #[derive(Clone, Copy)] pub struct Timestamp;
 
 #[derive(Clone, Copy)] pub struct Nullable<T: NativeSqlType>(T);

tests/expressions/date_and_time.rs

@@ -1,5 +1,6 @@
 use schema::connection;
 use yaqb::*;
+use yaqb::types::structs::*;
 use yaqb::expression::dsl::*;
 
 table! {
@@ -10,6 +11,13 @@ table! {
     }
 }
 
+table! {
+    has_time {
+        id -> Serial,
+        time -> Time,
+    }
+}
+
 #[test]
 fn now_executes_sql_function_now() {
     use self::has_timestamps::dsl::*;
@@ -52,10 +60,35 @@ fn date_uses_sql_function_date() {
     assert_eq!(expected_data, actual_data);
 }
 
+#[test]
+fn time_is_deserialized_properly() {
+    use self::has_time::dsl::*;
+
+    let connection = connection();
+    setup_test_table(&connection);
+    connection.execute("INSERT INTO has_time (\"time\") VALUES
+                       ('00:00:01'), ('00:02:00'), ('03:00:00')
+                       ").unwrap();
+    let one_second = PgTime(1_000_000);
+    let two_minutes = PgTime(120_000_000);
+    let three_hours = PgTime(10_800_000_000);
+    let expected_data = vec![one_second, two_minutes, three_hours];
+
+    let actual_data: Vec<_> = has_time.select(time)
+        .load(&connection)
+        .unwrap().collect();
+    assert_eq!(expected_data, actual_data);
+}
+
+
 fn setup_test_table(conn: &Connection) {
     conn.execute("CREATE TABLE has_timestamps (
         id SERIAL PRIMARY KEY,
         created_at TIMESTAMP NOT NULL,
         updated_at TIMESTAMP NOT NULL DEFAULT NOW()
     )").unwrap();
+    conn.execute("CREATE TABLE has_time (
+        id SERIAL PRIMARY KEY,
+        \"time\" TIME NOT NULL
+    )").unwrap();
 }

tests/types_roundtrip.rs

@@ -3,6 +3,7 @@ use quickcheck::quickcheck;
 use schema::connection;
 use yaqb::*;
 use yaqb::result::Error;
+use yaqb::types::structs::*;
 use yaqb::types::{NativeSqlType, ToSql, Nullable, Array};
 
 fn test_type_round_trips<ST, T>(value: T, type_name: &str) -> bool where
@@ -16,7 +17,7 @@ fn test_type_round_trips<ST, T>(value: T, type_name: &str) -> bool where
         Ok(mut val) => value == val.nth(0).unwrap(),
         Err(Error::DatabaseError(msg)) =>
             &msg == "ERROR:  invalid byte sequence for encoding \"UTF8\": 0x00\n",
-        _ => false,
+        Err(e) => panic!("Query failed: {:?}", e),
     }
 }
 
@@ -53,48 +54,35 @@ test_round_trip!(string_roundtrips, VarChar, String, "varchar");
 test_round_trip!(text_roundtrips, Text, String, "text");
 test_round_trip!(binary_roundtrips, Binary, Vec<u8>, "bytea");
 
-#[test]
-fn timestamp_roundtrip() {
-    use yaqb::types::structs::PgTimestamp;
+macro_rules! test_newtype_round_trip {
+    ($test_name:ident, $sql_type:ident, $newtype:ident, $tpe:ty, $sql_type_name:expr) => {
+        #[test]
+        fn $test_name() {
+            fn round_trip(val: $tpe) -> bool {
+                test_type_round_trips::<types::$sql_type, _>($newtype(val), $sql_type_name)
+            }
 
-    fn round_trip(val: i64) -> bool {
-        test_type_round_trips::<types::Timestamp, _>(PgTimestamp(val), "timestamp")
-    }
+            fn option_round_trip(val: Option<$tpe>) -> bool {
+                let val = val.map($newtype);
+                test_type_round_trips::<Nullable<types::$sql_type>, _>(val, $sql_type_name)
+            }
 
-    fn option_round_trip(val: Option<i64>) -> bool {
-        let val = val.map(PgTimestamp);
-        test_type_round_trips::<Nullable<types::Timestamp>, _>(val, "timestamp")
-    }
+            fn vec_round_trip(val: Vec<$tpe>) -> bool {
+                let val: Vec<_> = val.into_iter().map($newtype).collect();
+                test_type_round_trips::<Array<types::$sql_type>, _>(val, concat!($sql_type_name, "[]"))
+            }
 
-    fn vec_round_trip(val: Vec<i64>) -> bool {
-        let val: Vec<_> = val.into_iter().map(PgTimestamp).collect();
-        test_type_round_trips::<Array<types::Timestamp>, _>(val, "timestamp[]")
+            quickcheck(round_trip as fn($tpe) -> bool);
+            quickcheck(option_round_trip as fn(Option<$tpe>) -> bool);
+            quickcheck(vec_round_trip as fn(Vec<$tpe>) -> bool);
+        }
     }
-
-    quickcheck(round_trip as fn(i64) -> bool);
-    quickcheck(option_round_trip as fn(Option<i64>) -> bool);
-    quickcheck(vec_round_trip as fn(Vec<i64>) -> bool);
 }
 
-#[test]
-fn date_roundtrip() {
-    use yaqb::types::structs::PgDate;
-
-    fn round_trip(val: i32) -> bool {
-        test_type_round_trips::<types::Date, _>(PgDate(val), "date")
-    }
-
-    fn option_round_trip(val: Option<i32>) -> bool {
-        let val = val.map(PgDate);
-        test_type_round_trips::<Nullable<types::Date>, _>(val, "date")
-    }
-
-    fn vec_round_trip(val: Vec<i32>) -> bool {
-        let val: Vec<_> = val.into_iter().map(PgDate).collect();
-        test_type_round_trips::<Array<types::Date>, _>(val, "date[]")
-    }
-
-    quickcheck(round_trip as fn(i32) -> bool);
-    quickcheck(option_round_trip as fn(Option<i32>) -> bool);
-    quickcheck(vec_round_trip as fn(Vec<i32>) -> bool);
+fn to_pg_time(int: i64) -> ::yaqb::types::structs::PgTime {
+    PgTime(::std::cmp::max(0, int))
 }
+
+test_newtype_round_trip!(date_roundtrips, Date, PgDate, i32, "date");
+test_newtype_round_trip!(time_roundtrips, Time, to_pg_time, i64, "time");
+test_newtype_round_trip!(timestamp_roundtrips, Timestamp, PgTimestamp, i64, "timestamp");