Add support for SystemTime from the standard library

This feature is still unstable, but I think we can manage to keep up
support for it.

We should point back at released quickcheck after
BurntSushi/quickcheck#110 is merged and
released.

Author: sgrif

CHANGELOG.md

@@ -21,6 +21,9 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
   in the standard library, a dumb struct has been provided which mirrors what
   Postgres provides, which can be converted into whatever crate you are using.
 
+* Timestamp columns can now be used with `std::time::SystemTime` when compiled
+  with `--features unstable`
+
 ## [0.2.0] - 2015-11-30
 
 ### Added

bin/test

@@ -1,3 +1,3 @@
 #!/bin/sh
-(cd diesel && cargo test) &&
+(cd diesel && cargo test --features unstable) &&
   (cd diesel_tests && cargo test --features unstable --no-default-features)

diesel/Cargo.toml

@@ -13,10 +13,10 @@ keywords = ["orm", "database", "postgres", "postgresql", "sql"]
 libc = "0.2.*"
 pq-sys = "0.2.*"
 byteorder = "0.3.*"
-quickcheck = { version = "^0.2.24", optional = true }
+quickcheck = { git = "https://github.com/sgrif/quickcheck.git", rev = "7020692b18196d9d29718b31d8b2c7d1c4df3190", optional = true }
 
 [dev-dependencies]
-quickcheck = "^0.2.24"
+quickcheck = { git = "https://github.com/sgrif/quickcheck.git", rev = "7020692b18196d9d29718b31d8b2c7d1c4df3190" }
 dotenv = "0.4.0"
 
 [features]

diesel/src/lib.rs

@@ -2,6 +2,7 @@
 //! interactions. [A getting started guide](https://github.com/sgrif/diesel#getting-started) can be
 //! found in the README.
 #![deny(warnings)]
+#![cfg_attr(feature = "unstable", feature(time2))]
 pub mod expression;
 #[doc(hidden)]
 pub mod persistable;

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

@@ -1,5 +1,3 @@
-extern crate byteorder;
-
 use std::error::Error;
 use std::io::Write;
 use std::ops::Add;
@@ -12,6 +10,8 @@ use types::{self, NativeSqlType, FromSql, ToSql, IsNull};
 
 #[cfg(feature = "quickcheck")]
 mod quickcheck_impls;
+#[cfg(feature = "unstable")]
+mod std_time;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 /// Timestamps are represented in Postgres as a 32 bit signed integer representing the number of

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

@@ -0,0 +1,67 @@
+use std::error::Error;
+use std::io::Write;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use expression::bound::Bound;
+use expression::{Expression, AsExpression};
+use types::{self, ToSql, FromSql, IsNull, Nullable, Timestamp, NativeSqlType};
+use query_source::Queriable;
+
+expression_impls! {
+    Timestamp -> SystemTime,
+}
+
+queriable_impls! {
+    Timestamp -> SystemTime,
+}
+
+fn pg_epoch() -> SystemTime {
+    let thirty_years = Duration::from_secs(946684800);
+    UNIX_EPOCH + thirty_years
+}
+
+impl ToSql<types::Timestamp> for SystemTime {
+    fn to_sql<W: Write>(&self, out: &mut W) -> Result<IsNull, Box<Error>> {
+        let (before_epoch, duration) = match self.duration_from_earlier(pg_epoch()) {
+            Ok(duration) => (false, duration),
+            Err(time_err) => (true, time_err.duration()),
+        };
+        let time_since_epoch = if before_epoch {
+            -(duration_to_usecs(duration) as i64)
+        } else {
+            duration_to_usecs(duration) as i64
+        };
+        ToSql::<types::BigInt>::to_sql(&time_since_epoch, out)
+    }
+}
+
+impl FromSql<types::Timestamp> for SystemTime {
+    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
+        let usecs_passed = try!(<i64 as FromSql<types::BigInt>>::from_sql(bytes));
+        let before_epoch = usecs_passed < 0;
+        let time_passed = usecs_to_duration(usecs_passed.abs() as u64);
+
+        if before_epoch {
+            Ok(pg_epoch() - time_passed)
+        } else {
+            Ok(pg_epoch() + time_passed)
+        }
+    }
+}
+
+const USEC_PER_SEC: u64 = 1_000_000;
+const NANO_PER_USEC: u32 = 1_000;
+
+fn usecs_to_duration(usecs_passed: u64) -> Duration {
+    let usecs_passed = usecs_passed;
+    let seconds = usecs_passed / USEC_PER_SEC;
+    let subsecond_usecs = usecs_passed % USEC_PER_SEC;
+    let subseconds = subsecond_usecs as u32 * NANO_PER_USEC;
+    Duration::new(seconds, subseconds)
+}
+
+fn duration_to_usecs(duration: Duration) -> u64 {
+    let seconds = duration.as_secs() * USEC_PER_SEC;
+    let subseconds = duration.subsec_nanos() / NANO_PER_USEC;
+    seconds + subseconds as u64
+}

diesel/src/types/impls/mod.rs

@@ -53,6 +53,18 @@ macro_rules! expression_impls {
     }
 }
 
+macro_rules! queriable_impls {
+    ($($Source:ident -> $Target:ty),+,) => {$(
+        impl Queriable<types::$Source> for $Target {
+            type Row = Self;
+
+            fn build(row: Self::Row) -> Self {
+                row
+            }
+        }
+    )+}
+}
+
 macro_rules! primitive_impls {
     ($($Source:ident -> ($Target:ty, $oid:expr)),+,) => {
         $(
@@ -65,15 +77,8 @@ macro_rules! primitive_impls {
                     types::$Source
                 }
             }
-
-            impl Queriable<types::$Source> for $Target {
-                type Row = Self;
-
-                fn build(row: Self::Row) -> Self {
-                    row
-                }
-            }
         )+
+        queriable_impls!($($Source -> $Target),+,);
         expression_impls!($($Source -> $Target),+,);
     }
 }

diesel_tests/Cargo.toml

@@ -18,12 +18,12 @@ syntex = { version = "^0.22.0", optional = true }
 syntex_syntax = { version = "^0.22.0", optional = true }
 
 [dev-dependencies]
-quickcheck = "*"
+quickcheck = { git = "https://github.com/sgrif/quickcheck.git", rev = "7020692b18196d9d29718b31d8b2c7d1c4df3190" }
 dotenv = "0.4.0"
 
 [features]
 default = ["syntex", "syntex_syntax", "diesel_codegen/with-syntex"]
-unstable = ["compiletest_rs", "diesel_codegen/nightly"]
+unstable = ["compiletest_rs", "diesel_codegen/nightly", "diesel/unstable", "quickcheck/unstable"]
 
 [[test]]
 name = "compile_tests"

diesel_tests/tests/lib.rs

@@ -1,4 +1,4 @@
-#![cfg_attr(feature = "unstable", feature(custom_derive, plugin, custom_attribute))]
+#![cfg_attr(feature = "unstable", feature(custom_derive, plugin, custom_attribute, time2))]
 #![cfg_attr(feature = "unstable", plugin(diesel_codegen))]
 
 extern crate quickcheck;

diesel_tests/tests/types_roundtrip.rs

@@ -1,12 +1,12 @@
-use quickcheck::quickcheck;
+pub use quickcheck::quickcheck;
 
-use schema::connection;
-use diesel::*;
-use diesel::result::Error;
-use diesel::data_types::*;
-use diesel::types::{NativeSqlType, ToSql, Nullable, Array};
+pub use schema::connection;
+pub use diesel::*;
+pub use diesel::result::Error;
+pub use diesel::data_types::*;
+pub use diesel::types::{NativeSqlType, ToSql, Nullable, Array};
 
-fn test_type_round_trips<ST, T>(value: T, type_name: &str) -> bool where
+pub fn test_type_round_trips<ST, T>(value: T, type_name: &str) -> bool where
     ST: NativeSqlType,
     T: ToSql<ST> + Queriable<ST> + PartialEq,
 {
@@ -58,3 +58,11 @@ test_round_trip!(time_roundtrips, Time, PgTime, "time");
 test_round_trip!(timestamp_roundtrips, Timestamp, PgTimestamp, "timestamp");
 test_round_trip!(interval_roundtrips, Interval, PgInterval, "interval");
 test_round_trip!(numeric_roundtrips, Numeric, PgNumeric, "numeric");
+
+#[cfg(feature = "unstable")]
+mod unstable_types {
+    use super::*;
+    use std::time::SystemTime;
+
+    test_round_trip!(systemtime_roundtrips, Timestamp, SystemTime, "timestamp");
+}