Update to postgres 0.17, refactor chrono support, drop time support

- Updates integration and tests to postgres 0.17
- Moves chrono crate support to "with-chrono-0_4" to match postgres crate
- Drops time crate support since it was dropped in postgres crate

Author: lfittl

Cargo.toml

@@ -8,14 +8,12 @@ repository = "https://github.com/sfackler/rust-postgres-range"
 documentation = "https://sfackler.github.io/rust-postgres-range/doc/v0.9.0/postgres_range"
 
 [features]
-with-time = ["time", "postgres-shared/with-time"]
-with-chrono = ["chrono", "postgres-shared/with-chrono"]
+with-chrono-0_4 = ["chrono-04", "postgres-types/with-chrono-0_4"]
 
 [dependencies]
-time = { version = "0.1", optional = true }
-postgres-protocol = "0.3"
-chrono = { version = "0.4.0", optional = true }
-postgres-shared = "0.4.0"
+postgres-protocol = "0.5"
+postgres-types = "0.1"
+chrono-04 = { version = "0.4", package = "chrono", optional = true }
 
 [dev-dependencies]
-postgres = { version = "0.15", features = ["with-time"] }
+postgres = { version = "0.17" }

src/chrono_04.rs

@@ -0,0 +1,23 @@
+use chrono_04::{DateTime, NaiveDateTime, TimeZone};
+
+use crate::{Normalizable, RangeBound, BoundSided};
+
+impl<T> Normalizable for DateTime<T>
+    where T: TimeZone {
+    fn normalize<S>(bound: RangeBound<S, DateTime<T>>) -> RangeBound<S, DateTime<T>>
+    where
+        S: BoundSided,
+    {
+        bound
+    }
+}
+
+impl Normalizable for NaiveDateTime
+{
+    fn normalize<S>(bound: RangeBound<S, NaiveDateTime>) -> RangeBound<S, NaiveDateTime>
+    where
+        S: BoundSided,
+    {
+        bound
+    }
+}

src/impls.rs

@@ -1,14 +1,15 @@
 use std::error::Error;
-use postgres_shared::types::{FromSql, IsNull, Kind, ToSql, Type};
+use postgres_types::{FromSql, IsNull, Kind, ToSql, Type};
+use postgres_types::private::BytesMut;
 use postgres_protocol::{self as protocol, types};
 
 use {BoundSided, BoundType, Normalizable, Range, RangeBound};
 
-impl<T> FromSql for Range<T>
+impl<'a, T> FromSql<'a> for Range<T>
 where
-    T: PartialOrd + Normalizable + FromSql,
+    T: PartialOrd + Normalizable + FromSql<'a>,
 {
-    fn from_sql(ty: &Type, raw: &[u8]) -> Result<Range<T>, Box<Error + Sync + Send>> {
+    fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Range<T>, Box<dyn Error + Sync + Send>> {
         let element_type = match ty.kind() {
             &Kind::Range(ref ty) => ty,
             _ => panic!("unexpected type {:?}", ty),
@@ -32,9 +33,9 @@ where
     }
 }
 
-fn bound_from_sql<T, S>(bound: types::RangeBound<Option<&[u8]>>, ty: &Type) -> Result<Option<RangeBound<S, T>>, Box<Error + Sync + Send>>
+fn bound_from_sql<'a, T, S>(bound: types::RangeBound<Option<&'a [u8]>>, ty: &Type) -> Result<Option<RangeBound<S, T>>, Box<dyn Error + Sync + Send>>
 where
-    T: PartialOrd + Normalizable + FromSql,
+    T: PartialOrd + Normalizable + FromSql<'a>,
     S: BoundSided,
 {
     match bound {
@@ -60,7 +61,7 @@ impl<T> ToSql for Range<T>
 where
     T: PartialOrd + Normalizable + ToSql,
 {
-    fn to_sql(&self, ty: &Type, buf: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, ty: &Type, buf: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
         let element_type = match ty.kind() {
             &Kind::Range(ref ty) => ty,
             _ => panic!("unexpected type {:?}", ty),
@@ -89,7 +90,7 @@ where
     to_sql_checked!();
 }
 
-fn bound_to_sql<S, T>(bound: Option<&RangeBound<S, T>>, ty: &Type, buf: &mut Vec<u8>) -> Result<types::RangeBound<protocol::IsNull>, Box<Error + Sync + Send>>
+fn bound_to_sql<S, T>(bound: Option<&RangeBound<S, T>>, ty: &Type, buf: &mut BytesMut) -> Result<types::RangeBound<protocol::IsNull>, Box<dyn Error + Sync + Send>>
 where
     S: BoundSided,
     T: ToSql,
@@ -114,10 +115,10 @@ where
 mod test {
     use std::fmt;
 
-    use postgres::{Connection, TlsMode};
+    use postgres::{Client, NoTls};
     use postgres::types::{FromSql, ToSql};
-    #[cfg(feature = "with-time")]
-    use time::{self, Timespec};
+    #[cfg(feature = "with-chrono-0_4")]
+    use chrono_04::{TimeZone, Utc, Duration};
 
     macro_rules! test_range {
         ($name:expr, $t:ty, $low:expr, $low_str:expr, $high:expr, $high_str:expr) => ({
@@ -140,16 +141,21 @@ mod test {
         })
     }
 
-    fn test_type<T: PartialEq + FromSql + ToSql, S: fmt::Display>(sql_type: &str, checks: &[(T, S)]) {
-        let conn = Connection::connect("postgres://postgres@localhost", TlsMode::None).unwrap();
+
+    fn test_type<T, S>(sql_type: &str, checks: &[(T, S)])
+    where for<'a>
+        T: Sync + PartialEq + FromSql<'a> + ToSql,
+        S: fmt::Display
+    {
+        let mut conn = Client::connect("postgres://postgres@localhost", NoTls).unwrap();
         for &(ref val, ref repr) in checks {
             let stmt = conn.prepare(&*format!("SELECT {}::{}", *repr, sql_type))
                 .unwrap();
-            let result = stmt.query(&[]).unwrap().iter().next().unwrap().get(0);
+            let result = conn.query(&stmt, &[]).unwrap().iter().next().unwrap().get(0);
             assert!(val == &result);
 
             let stmt = conn.prepare(&*format!("SELECT $1::{}", sql_type)).unwrap();
-            let result = stmt.query(&[val]).unwrap().iter().next().unwrap().get(0);
+            let result = conn.query(&stmt, &[val]).unwrap().iter().next().unwrap().get(0);
             assert!(val == &result);
         }
     }
@@ -164,25 +170,19 @@ mod test {
         test_range!("INT8RANGE", i64, 100i64, "100", 200i64, "200")
     }
 
-    #[cfg(feature = "with-time")]
-    fn test_timespec_range_params(sql_type: &str) {
-        fn t(time: &str) -> Timespec {
-            time::strptime(time, "%Y-%m-%d").unwrap().to_timespec()
-        }
-        let low = "1970-01-01";
-        let high = "1980-01-01";
-        test_range!(sql_type, Timespec, t(low), low, t(high), high);
-    }
-
     #[test]
-    #[cfg(feature = "with-time")]
+    #[cfg(feature = "with-chrono-0_4")]
     fn test_tsrange_params() {
-        test_timespec_range_params("TSRANGE");
+        let low = Utc.timestamp(0, 0);
+        let high = low + Duration::days(10);
+        test_range!("TSRANGE", NaiveDateTime, low.naive_utc(), "1970-01-01", high.naive_utc(), "1970-01-11");
     }
 
     #[test]
-    #[cfg(feature = "with-time")]
+    #[cfg(feature = "with-chrono-0_4")]
     fn test_tstzrange_params() {
-        test_timespec_range_params("TSTZRANGE");
+        let low = Utc.timestamp(0, 0);
+        let high = low + Duration::days(10);
+        test_range!("TSTZRANGE", DateTime<Utc>, low, "1970-01-01", high, "1970-01-11");
     }
 }

src/lib.rs

@@ -3,25 +3,19 @@
 
 extern crate postgres_protocol;
 #[macro_use(to_sql_checked)]
-extern crate postgres_shared;
+extern crate postgres_types;
 
-#[cfg(feature = "with-time")]
-extern crate time;
-#[cfg(feature = "with-chrono")]
-extern crate chrono;
+#[cfg(feature = "with-chrono-0_4")]
+mod chrono_04;
 
 #[cfg(test)]
 extern crate postgres;
 
-#[cfg(feature = "with-chrono")]
-use chrono::{DateTime, NaiveDateTime, TimeZone};
 use std::cmp::Ordering;
 use std::fmt;
 use std::i32;
 use std::i64;
 use std::marker::PhantomData;
-#[cfg(feature = "with-time")]
-use time::Timespec;
 
 use BoundSide::{Lower, Upper};
 use BoundType::{Exclusive, Inclusive};
@@ -155,38 +149,6 @@ macro_rules! bounded_normalizable {
 bounded_normalizable!(i32);
 bounded_normalizable!(i64);
 
-#[cfg(feature = "with-time")]
-impl Normalizable for Timespec {
-    fn normalize<S>(bound: RangeBound<S, Timespec>) -> RangeBound<S, Timespec>
-    where
-        S: BoundSided,
-    {
-        bound
-    }
-}
-
-#[cfg(feature = "with-chrono")]
-impl<T> Normalizable for DateTime<T>
-    where T: TimeZone {
-    fn normalize<S>(bound: RangeBound<S, DateTime<T>>) -> RangeBound<S, DateTime<T>>
-    where
-        S: BoundSided,
-    {
-        bound
-    }
-}
-
-#[cfg(feature = "with-chrono")]
-impl Normalizable for NaiveDateTime
-{
-    fn normalize<S>(bound: RangeBound<S, NaiveDateTime>) -> RangeBound<S, NaiveDateTime>
-    where
-        S: BoundSided,
-    {
-        bound
-    }
-}
-
 /// The possible sides of a bound.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum BoundSide {