implement arithmetics to timestamptz (diesel-rs#1657)

* implement add and sub to timestamptz

* fix typo

* create table before testing

* allow add and sub to the generated column structs

* test against operations on `now`

* use timestamptz only on postgres

* fix typo

* fix typo

* fix typo

* give up testing now as timestamptz. Leaving it as another issue

* apply #[cfg] in the minimal unit

* explicitly use timezone

* cfg out timestamptz helper function

* trim a blank line

Author: KeenS

diesel/src/macros/ops.rs

@@ -80,5 +80,6 @@ macro_rules! __diesel_generate_ops_impls_if_date_time {
     ($column_name:ident, Time) => { date_time_expr!($column_name); };
     ($column_name:ident, Date) => { date_time_expr!($column_name); };
     ($column_name:ident, Timestamp) => { date_time_expr!($column_name); };
+    ($column_name:ident, Timestamptz) => { date_time_expr!($column_name); };
     ($column_name:ident, $non_date_time_type:ty) => {};
 }

diesel/src/pg/types/mod.rs

@@ -1,23 +1,23 @@
 //! PostgreSQL specific types
 
 mod array;
-mod ranges;
 #[doc(hidden)]
 pub mod date_and_time;
 #[doc(hidden)]
 pub mod floats;
+mod integers;
+#[cfg(feature = "serde_json")]
+mod json;
+#[doc(hidden)]
+pub mod money;
 #[cfg(feature = "network-address")]
 mod network_address;
-mod integers;
 mod numeric;
 mod primitives;
+mod ranges;
 mod record;
 #[cfg(feature = "uuid")]
 mod uuid;
-#[cfg(feature = "serde_json")]
-mod json;
-#[doc(hidden)]
-pub mod money;
 
 /// PostgreSQL specific SQL types
 ///
@@ -488,3 +488,29 @@ pub mod sql_types {
     #[postgres(oid = "650", array_oid = "651")]
     pub struct Cidr;
 }
+
+mod ops {
+    use super::sql_types::*;
+    use sql_types::ops::*;
+    use sql_types::{Interval, Nullable};
+
+    impl Add for Timestamptz {
+        type Rhs = Interval;
+        type Output = Timestamptz;
+    }
+
+    impl Add for Nullable<Timestamptz> {
+        type Rhs = Nullable<Interval>;
+        type Output = Nullable<Timestamptz>;
+    }
+
+    impl Sub for Timestamptz {
+        type Rhs = Interval;
+        type Output = Timestamptz;
+    }
+
+    impl Sub for Nullable<Timestamptz> {
+        type Rhs = Nullable<Interval>;
+        type Output = Nullable<Timestamptz>;
+    }
+}

diesel_tests/tests/expressions/date_and_time.rs

@@ -12,13 +12,34 @@ table! {
     }
 }
 
+#[cfg(feature = "postgres")]
+table! {
+    has_timestamptzs {
+        id -> Integer,
+        created_at -> Timestamptz,
+        updated_at -> Timestamptz,
+    }
+}
+
 table! {
     has_time {
         id -> Integer,
         time -> Time,
     }
 }
 
+#[cfg(feature = "postgres")]
+table! {
+    nullable_date_and_time {
+        id -> Integer,
+        timestamp -> Nullable<Timestamp>,
+        timestamptz -> Nullable<Timestamptz>,
+        time -> Nullable<Time>,
+        date -> Nullable<Date>,
+    }
+}
+
+#[cfg(not(feature = "postgres"))]
 table! {
     nullable_date_and_time {
         id -> Integer,
@@ -226,6 +247,30 @@ fn adding_interval_to_timestamp() {
     assert_eq!(expected_data, actual_data);
 }
 
+#[test]
+#[cfg(feature = "postgres")]
+fn adding_interval_to_timestamptz() {
+    use self::has_timestamptzs::dsl::*;
+    use diesel::dsl::sql;
+
+    let connection = connection();
+    setup_test_table(&connection);
+    connection
+        .execute(
+            "INSERT INTO has_timestamptzs (created_at, updated_at) VALUES
+                       ('2015-11-15 06:07:41+0100', '2015-11-15 20:07:41+0100')",
+        )
+        .unwrap();
+
+    let expected_data = select(sql::<sql_types::Timestamptz>(
+        "'2015-11-16 06:07:41+0100'::timestamptz",
+    )).get_result::<PgTimestamp>(&connection);
+    let actual_data = has_timestamptzs
+        .select(created_at + 1.day())
+        .first::<PgTimestamp>(&connection);
+    assert_eq!(expected_data, actual_data);
+}
+
 #[test]
 #[cfg(feature = "postgres")]
 fn adding_interval_to_nullable_things() {
@@ -236,8 +281,8 @@ fn adding_interval_to_nullable_things() {
     setup_test_table(&connection);
     connection
         .execute(
-            "INSERT INTO nullable_date_and_time (timestamp, date, time) VALUES
-                       ('2017-08-20 18:13:37', '2017-08-20', '18:13:37')",
+            "INSERT INTO nullable_date_and_time (timestamp, timestamptz, date, time) VALUES
+                       ('2017-08-20 18:13:37', '2017-08-20 18:13:37+0100', '2017-08-20', '18:13:37')",
         )
         .unwrap();
 
@@ -249,6 +294,14 @@ fn adding_interval_to_nullable_things() {
         .first::<Option<PgTimestamp>>(&connection);
     assert_eq!(expected_data, actual_data);
 
+    let expected_data = select(sql::<Nullable<sql_types::Timestamptz>>(
+        "'2017-08-21 18:13:37+0100'::timestamptz",
+    )).get_result::<Option<PgTimestamp>>(&connection);
+    let actual_data = nullable_date_and_time
+        .select(timestamptz + 1.day())
+        .first::<Option<PgTimestamp>>(&connection);
+    assert_eq!(expected_data, actual_data);
+
     let expected_data = select(sql::<Nullable<sql_types::Timestamp>>(
         "'2017-08-21'::timestamp",
     )).get_result::<Option<PgTimestamp>>(&connection);
@@ -281,6 +334,19 @@ fn setup_test_table(conn: &TestConnection) {
     ).execute(conn)
         .unwrap();
 
+    #[cfg(feature = "postgres")]
+    create_table(
+        "has_timestamptzs",
+        (
+            integer("id").primary_key().auto_increment(),
+            timestamptz("created_at").not_null(),
+            timestamptz("updated_at")
+                .not_null()
+                .default("CURRENT_TIMESTAMP"),
+        ),
+    ).execute(conn)
+        .unwrap();
+
     create_table(
         "has_time",
         (
@@ -295,6 +361,8 @@ fn setup_test_table(conn: &TestConnection) {
         (
             integer("id").primary_key().auto_increment(),
             timestamp("timestamp"),
+            #[cfg(feature = "postgres")]
+            timestamptz("timestamptz"),
             time("time"),
             date("date"),
         ),

diesel_tests/tests/schema_dsl/functions.rs

@@ -18,6 +18,11 @@ pub fn timestamp<'a>(name: &'a str) -> Column<'a, sql_types::VarChar> {
     Column::new(name, "TIMESTAMP")
 }
 
+#[cfg(feature = "postgres")]
+pub fn timestamptz<'a>(name: &'a str) -> Column<'a, sql_types::VarChar> {
+    Column::new(name, "TIMESTAMPTZ")
+}
+
 pub fn time<'a>(name: &'a str) -> Column<'a, sql_types::VarChar> {
     Column::new(name, "TIME")
 }