From 084add9cdbe9056481990dd614409694467c3596 Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Sat, 29 Feb 2020 22:38:48 +0300
Subject: [PATCH 1/9] #115: implement time-rs support

---
 .github/workflows/rust.yml           |  96 +++++++--
 Cargo.lock                           |  33 ++++
 Cargo.toml                           |  13 +-
 README.md                            |  26 +--
 sqlx-core/Cargo.toml                 |   3 +-
 sqlx-core/src/mysql/types/mod.rs     |   3 +
 sqlx-core/src/mysql/types/time.rs    | 276 ++++++++++++++++++++++++++
 sqlx-core/src/postgres/types/mod.rs  |   3 +
 sqlx-core/src/postgres/types/time.rs | 286 +++++++++++++++++++++++++++
 sqlx-core/src/types.rs               |   6 +
 sqlx-macros/Cargo.toml               |   1 +
 sqlx-macros/src/database/mysql.rs    |  20 +-
 sqlx-macros/src/database/postgres.rs |  20 +-
 tests/mysql-types-chrono.rs          |   4 +
 tests/mysql-types-time.rs            |  92 +++++++++
 tests/postgres-types-chrono.rs       |   4 +
 tests/postgres-types-time.rs         | 108 ++++++++++
 17 files changed, 958 insertions(+), 36 deletions(-)
 create mode 100644 sqlx-core/src/mysql/types/time.rs
 create mode 100644 sqlx-core/src/postgres/types/time.rs
 create mode 100644 tests/mysql-types-time.rs
 create mode 100644 tests/postgres-types-time.rs

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index ab6da813..f0e38df3 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -39,25 +39,25 @@ jobs:
 
     # check w/deny warnings in sqlx-core: async-std
     - working-directory: sqlx-core
-      run: cargo rustc --no-default-features --features 'chrono uuid postgres mysql tls runtime-async-std' -- -D warnings --emit=metadata
+      run: cargo rustc --no-default-features --features 'chrono time uuid postgres mysql tls runtime-async-std' -- -D warnings --emit=metadata
 
     # check w/deny warnings in sqlx-core: tokio
     # `cargo rustc -p sqlx-core` ignores `--no-default-features` and builds with `runtime-async-std` anyway
     # https://github.com/rust-lang/cargo/issues/5364
     - working-directory: sqlx-core
-      run: cargo rustc --no-default-features --features 'chrono uuid postgres mysql tls runtime-tokio' -- -D warnings --emit=metadata
+      run: cargo rustc --no-default-features --features 'chrono time uuid postgres mysql tls runtime-tokio' -- -D warnings --emit=metadata
 
     # check w/deny warnings: async-std
-    - run: cargo rustc --no-default-features --features 'chrono uuid postgres mysql macros tls runtime-async-std' -- -D warnings --emit=metadata
+    - run: cargo rustc --no-default-features --features 'chrono time uuid postgres mysql macros tls runtime-async-std' -- -D warnings --emit=metadata
 
     # check w/deny warnings: tokio
-    - run: cargo rustc --no-default-features --features 'chrono uuid postgres mysql macros tls runtime-tokio' -- -D warnings --emit=metadata
+    - run: cargo rustc --no-default-features --features 'chrono time uuid postgres mysql macros tls runtime-tokio' -- -D warnings --emit=metadata
 
     # unit test: async-std
-    - run: cargo test --manifest-path sqlx-core/Cargo.toml --no-default-features --features 'chrono uuid postgres mysql tls runtime-async-std'
+    - run: cargo test --manifest-path sqlx-core/Cargo.toml --no-default-features --features 'chrono time uuid postgres mysql tls runtime-async-std'
 
     # unit test: tokio
-    - run: cargo test --manifest-path sqlx-core/Cargo.toml --no-default-features --features 'chrono uuid postgres mysql tls runtime-tokio'
+    - run: cargo test --manifest-path sqlx-core/Cargo.toml --no-default-features --features 'chrono time uuid postgres mysql tls runtime-tokio'
 
     # Rust ------------------------------------------------
 
@@ -110,16 +110,37 @@ jobs:
 
     # -----------------------------------------------------
 
-    # integration test: async-std
+    # integration test: async-std (chrono)
     - run: cargo test --no-default-features --features 'runtime-async-std postgres macros uuid chrono tls'
       env:
         DATABASE_URL: postgres://postgres:postgres@localhost:${{ job.services.postgres.ports[5432] }}/postgres
 
-    # integration test: tokio
+    # integration test: async-std (time)
+    - run: cargo test --no-default-features --features 'runtime-async-std postgres macros uuid time tls'
+      env:
+        DATABASE_URL: postgres://postgres:postgres@localhost:${{ job.services.postgres.ports[5432] }}/postgres
+
+      # integration test: async-std (time + chrono)
+    - run: cargo test --no-default-features --features 'runtime-async-std postgres macros uuid time chrono tls'
+      env:
+        DATABASE_URL: postgres://postgres:postgres@localhost:${{ job.services.postgres.ports[5432] }}/postgres
+
+    # integration test: tokio (chrono)
     - run: cargo test --no-default-features --features 'runtime-tokio postgres macros uuid chrono tls'
       env:
         DATABASE_URL: postgres://postgres:postgres@localhost:${{ job.services.postgres.ports[5432] }}/postgres
 
+    # integration test: tokio (time)
+    - run: cargo test --no-default-features --features 'runtime-tokio postgres macros uuid time tls'
+      env:
+        DATABASE_URL: postgres://postgres:postgres@localhost:${{ job.services.postgres.ports[5432] }}/postgres
+
+    # integration test: tokio (time + chrono)
+    - run: cargo test --no-default-features --features 'runtime-tokio postgres macros uuid time chrono tls'
+      env:
+        DATABASE_URL: postgres://postgres:postgres@localhost:${{ job.services.postgres.ports[5432] }}/postgres
+
+
   mysql:
     needs: build
     runs-on: ubuntu-latest
@@ -162,20 +183,49 @@ jobs:
 
     # -----------------------------------------------------
 
-    # integration test: async-std
+    # integration test: async-std (chrono)
     - run: cargo test --no-default-features --features 'runtime-async-std mysql macros uuid chrono tls'
       env:
         # pass the path to the CA that the MySQL service generated
         # NOTE: Github Actions' YML parser doesn't handle multiline strings correctly
         DATABASE_URL: mysql://root:password@localhost:${{ job.services.mysql.ports[3306] }}/sqlx?ssl-mode=VERIFY_CA&ssl-ca=%2Fdata%2Fmysql%2Fca.pem
 
-    # integration test: tokio
+    # integration test: async-std (time)
+    - run: cargo test --no-default-features --features 'runtime-async-std mysql macros uuid time tls'
+      env:
+        # pass the path to the CA that the MySQL service generated
+        # NOTE: Github Actions' YML parser doesn't handle multiline strings correctly
+        DATABASE_URL: mysql://root:password@localhost:${{ job.services.mysql.ports[3306] }}/sqlx?ssl-mode=VERIFY_CA&ssl-ca=%2Fdata%2Fmysql%2Fca.pem
+
+    # integration test: async-std (time + chrono)
+    - run: cargo test --no-default-features --features 'runtime-async-std mysql macros uuid time chrono tls'
+      env:
+        # pass the path to the CA that the MySQL service generated
+        # NOTE: Github Actions' YML parser doesn't handle multiline strings correctly
+        DATABASE_URL: mysql://root:password@localhost:${{ job.services.mysql.ports[3306] }}/sqlx?ssl-mode=VERIFY_CA&ssl-ca=%2Fdata%2Fmysql%2Fca.pem
+
+    # integration test: tokio (chrono)
     - run: cargo test --no-default-features --features 'runtime-tokio mysql macros uuid chrono tls'
       env:
         # pass the path to the CA that the MySQL service generated
         # NOTE: Github Actions' YML parser doesn't handle multiline strings correctly
         DATABASE_URL: mysql://root:password@localhost:${{ job.services.mysql.ports[3306] }}/sqlx?ssl-mode=VERIFY_CA&ssl-ca=%2Fdata%2Fmysql%2Fca.pem
 
+    # integration test: tokio (time)
+    - run: cargo test --no-default-features --features 'runtime-tokio mysql macros uuid time tls'
+      env:
+        # pass the path to the CA that the MySQL service generated
+        # NOTE: Github Actions' YML parser doesn't handle multiline strings correctly
+        DATABASE_URL: mysql://root:password@localhost:${{ job.services.mysql.ports[3306] }}/sqlx?ssl-mode=VERIFY_CA&ssl-ca=%2Fdata%2Fmysql%2Fca.pem
+
+    # integration test: tokio (time + chrono)
+    - run: cargo test --no-default-features --features 'runtime-tokio mysql macros uuid time chrono tls'
+      env:
+        # pass the path to the CA that the MySQL service generated
+        # NOTE: Github Actions' YML parser doesn't handle multiline strings correctly
+        DATABASE_URL: mysql://root:password@localhost:${{ job.services.mysql.ports[3306] }}/sqlx?ssl-mode=VERIFY_CA&ssl-ca=%2Fdata%2Fmysql%2Fca.pem
+
+
   mariadb:
     needs: build
     runs-on: ubuntu-latest
@@ -216,12 +266,32 @@ jobs:
 
     # -----------------------------------------------------
 
-    # integration test: async-std
-    - run: cargo test --no-default-features --features 'runtime-async-std mysql macros chrono uuid chrono tls'
+    # integration test: async-std (chrono)
+    - run: cargo test --no-default-features --features 'runtime-async-std mysql macros chrono uuid tls'
       env:
         DATABASE_URL: mariadb://root:password@localhost:${{ job.services.mariadb.ports[3306] }}/sqlx
 
-    # integration test: tokio
+    # integration test: async-std (time)
+    - run: cargo test --no-default-features --features 'runtime-async-std mysql macros time uuid tls'
+      env:
+        DATABASE_URL: mariadb://root:password@localhost:${{ job.services.mariadb.ports[3306] }}/sqlx
+
+    # integration test: async-std (time + chrono)
+    - run: cargo test --no-default-features --features 'runtime-async-std mysql macros time chrono uuid tls'
+      env:
+        DATABASE_URL: mariadb://root:password@localhost:${{ job.services.mariadb.ports[3306] }}/sqlx
+
+    # integration test: tokio (chrono)
     - run: cargo test --no-default-features --features 'runtime-tokio mysql macros uuid chrono tls'
       env:
         DATABASE_URL: mariadb://root:password@localhost:${{ job.services.mariadb.ports[3306] }}/sqlx
+
+    # integration test: tokio (time)
+    - run: cargo test --no-default-features --features 'runtime-tokio mysql macros uuid time tls'
+      env:
+        DATABASE_URL: mariadb://root:password@localhost:${{ job.services.mariadb.ports[3306] }}/sqlx
+
+    # integration test: tokio (time + chrono)
+    - run: cargo test --no-default-features --features 'runtime-tokio mysql macros uuid time chrono tls'
+      env:
+        DATABASE_URL: mariadb://root:password@localhost:${{ job.services.mariadb.ports[3306] }}/sqlx
diff --git a/Cargo.lock b/Cargo.lock
index 4f654905..ba41cdf9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1521,6 +1521,7 @@ dependencies = [
  "rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "sha-1 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "sha2 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "time 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "tokio 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "url 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "uuid 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1718,6 +1719,35 @@ dependencies = [
  "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "time"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rustversion 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "time-macros 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "time-macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro-hack 0.5.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "time-macros-impl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "time-macros-impl"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro-hack 0.5.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 1.0.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "todos-postgres"
 version = "0.1.0"
@@ -2233,6 +2263,9 @@ dependencies = [
 "checksum thread_local 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
 "checksum tide 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "13c99b1991db81e611a2614cd1b07fec89ae33c5f755e1f8eb70826fb5af0eea"
 "checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
+"checksum time 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3043ac959c44dccc548a57417876c8fe241502aed69d880efc91166c02717a93"
+"checksum time-macros 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9ae9b6e9f095bc105e183e3cd493d72579be3181ad4004fceb01adbe9eecab2d"
+"checksum time-macros-impl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e987cfe0537f575b5fc99909de6185f6c19c3ad8889e2275e686a873d0869ba1"
 "checksum tokio 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)" = "5a09c0b5bb588872ab2f09afa13ee6e9dac11e10a0ec9e8e3ba39a5a5d530af6"
 "checksum tokio 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8fdd17989496f49cdc57978c96f0c9fe5e4a58a8bddc6813c449a4624f6a030b"
 "checksum tokio-buf 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8fb220f46c53859a4b7ec083e41dec9778ff0b1851c0942b211edb89e0ccdc46"
diff --git a/Cargo.toml b/Cargo.toml
index fff12f67..af92747f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,11 +26,11 @@ authors = [
 ]
 
 [package.metadata.docs.rs]
-features = [ "tls", "postgres", "mysql", "uuid", "chrono" ]
+features = [ "tls", "postgres", "mysql", "uuid", "chrono", "time" ]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
-default = [ "macros", "runtime-async-std" ]
+default = [ "macros", "runtime-async-std", "time", "postgres" ]
 macros = [ "sqlx-macros" ]
 tls = [ "sqlx-core/tls" ]
 
@@ -44,6 +44,7 @@ mysql = [ "sqlx-core/mysql", "sqlx-macros/mysql" ]
 
 # types
 chrono = [ "sqlx-core/chrono", "sqlx-macros/chrono" ]
+time = [ "sqlx-core/time", "sqlx-macros/time" ]
 uuid = [ "sqlx-core/uuid", "sqlx-macros/uuid" ]
 
 [dependencies]
@@ -83,6 +84,10 @@ required-features = [ "postgres" ]
 name = "postgres-types-chrono"
 required-features = [ "postgres", "chrono" ]
 
+[[test]]
+name = "postgres-types-time"
+required-features = [ "postgres", "time" ]
+
 [[test]]
 name = "mysql-types"
 required-features = [ "mysql" ]
@@ -91,6 +96,10 @@ required-features = [ "mysql" ]
 name = "mysql-types-chrono"
 required-features = [ "mysql", "chrono", "macros" ]
 
+[[test]]
+name = "mysql-types-time"
+required-features = [ "mysql", "time", "macros" ]
+
 [[test]]
 name = "derives"
 required-features = [ "macros" ]
diff --git a/README.md b/README.md
index 1b2346c5..f77de00a 100644
--- a/README.md
+++ b/README.md
@@ -43,11 +43,11 @@ SQLx is an async, pure Rust SQL crate featuring compile-time checked queries wit
 
  * **Truly Asynchronous**. Built from the ground-up using async/await for maximum concurrency.
 
- * **Type-safe SQL** (if you want it) without DSLs. Use the `query!()` macro to check your SQL and bind parameters at 
+ * **Type-safe SQL** (if you want it) without DSLs. Use the `query!()` macro to check your SQL and bind parameters at
  compile time. (You can still use dynamic SQL queries if you like.)
 
  * **Pure Rust**. The Postgres and MySQL/MariaDB drivers are written in pure Rust using **zero** unsafe code.
- 
+
  * **Runtime Agnostic**. Works on [async-std](https://crates.io/crates/async-std) or [tokio](https://crates.io/crates/tokio) with the `runtime-async-std` or `runtime-tokio` cargo feature flag.
 
 ## Install
@@ -71,17 +71,19 @@ sqlx = { version = "0.2", default-features = false, features = [ "runtime-tokio"
 #### Cargo Feature Flags
 
  * `runtime-async-std` (on by default): Use the `async-std` runtime.
- 
+
  * `runtime-tokio`: Use the `tokio` runtime. Mutually exclusive with the `runtime-async-std` feature.
- 
+
  * `postgres`: Add support for the Postgres database server.
- 
+
  * `mysql`: Add support for the MySQL (and MariaDB) database server.
- 
+
  * `uuid`: Add support for UUID (in Postgres).
- 
+
  * `chrono`: Add support for date and time types from `chrono`.
- 
+
+ * `time`: Add support for date and time types from `time` crate (simpler than `chrono`)
+
  * `tls`: Add support for TLS connections.
 
 ## Examples
@@ -97,7 +99,7 @@ let pool = sqlx::PgPool::new("postgres://localhost/database").await?;
 
 #### Dynamic
 
-The `sqlx::query` function provides general-purpose prepared statement execution. 
+The `sqlx::query` function provides general-purpose prepared statement execution.
 The result is an implementation of the `Row` trait. Values can be efficiently accessed by index or name.
 
 ```rust
@@ -105,18 +107,18 @@ let row = sqlx::query("SELECT is_active FROM users WHERE id = ?")
     .bind(some_user_id)
     .fetch_one(&mut &pool)
     .await?;
-    
+
 let is_active: bool = row.get("is_active");
 ```
 
 #### Static
 
-The `sqlx::query!` macro prepares the SQL query at compile time and interprets the result in order to constrain input types and 
+The `sqlx::query!` macro prepares the SQL query at compile time and interprets the result in order to constrain input types and
 infer output types. The result of `query!` is an anonymous struct (or named tuple).
 
 ```rust
 let countries = sqlx::query!(
-        "SELECT country, COUNT(*) FROM users GROUP BY country WHERE organization = ?", 
+        "SELECT country, COUNT(*) FROM users GROUP BY country WHERE organization = ?",
         organization
     )
     .fetch(&mut &pool) // -> impl Stream<Item = { country: String, count: i64 }>
diff --git a/sqlx-core/Cargo.toml b/sqlx-core/Cargo.toml
index 0cf72e78..3c435f76 100644
--- a/sqlx-core/Cargo.toml
+++ b/sqlx-core/Cargo.toml
@@ -24,7 +24,7 @@ runtime-tokio = [ "async-native-tls/runtime-tokio", "tokio" ]
 [dependencies]
 async-native-tls = { version = "0.3.2", default-features = false, optional = true }
 async-std = { version = "1.4.0", optional = true }
-tokio = { version = "0.2.9", default-features = false, features = [ "dns", "fs", "time", "tcp" ], optional = true } 
+tokio = { version = "0.2.9", default-features = false, features = [ "dns", "fs", "time", "tcp" ], optional = true }
 async-stream = { version = "0.2.0", default-features = false }
 base64 = { version = "0.11.0", default-features = false, optional = true, features = [ "std" ] }
 bitflags = { version = "1.2.1", default-features = false }
@@ -46,6 +46,7 @@ percent-encoding = "2.1.0"
 rand = { version = "0.7.3", default-features = false, optional = true, features = [ "std" ] }
 sha-1 = { version = "0.8.2", default-features = false, optional = true }
 sha2 = { version = "0.8.1", default-features = false, optional = true }
+time = { version = "0.2.7", default-features = false, optional = true }
 url = { version = "2.1.1", default-features = false }
 uuid = { version = "0.8.1", default-features = false, optional = true }
 hmac = { version = "0.7.1", default-features = false, optional = true }
diff --git a/sqlx-core/src/mysql/types/mod.rs b/sqlx-core/src/mysql/types/mod.rs
index 39e8252b..50b2141c 100644
--- a/sqlx-core/src/mysql/types/mod.rs
+++ b/sqlx-core/src/mysql/types/mod.rs
@@ -8,6 +8,9 @@ mod uint;
 #[cfg(feature = "chrono")]
 mod chrono;
 
+#[cfg(feature = "time")]
+mod time;
+
 use std::fmt::{self, Debug, Display};
 
 use crate::mysql::protocol::TypeId;
diff --git a/sqlx-core/src/mysql/types/time.rs b/sqlx-core/src/mysql/types/time.rs
new file mode 100644
index 00000000..201ee58a
--- /dev/null
+++ b/sqlx-core/src/mysql/types/time.rs
@@ -0,0 +1,276 @@
+use std::convert::TryFrom;
+
+use byteorder::{ByteOrder, LittleEndian};
+use time::{Date, Time, PrimitiveDateTime, OffsetDateTime, UtcOffset};
+
+use crate::decode::{Decode, DecodeError};
+use crate::encode::Encode;
+use crate::io::{Buf, BufMut};
+use crate::mysql::protocol::TypeId;
+use crate::mysql::types::MySqlTypeInfo;
+use crate::mysql::MySql;
+use crate::types::HasSqlType;
+
+impl HasSqlType<OffsetDateTime> for MySql {
+    fn type_info() -> MySqlTypeInfo {
+        MySqlTypeInfo::new(TypeId::TIMESTAMP)
+    }
+}
+
+impl Encode<MySql> for OffsetDateTime {
+    fn encode(&self, buf: &mut Vec<u8>) {
+        let utc_dt = self.to_offset(UtcOffset::UTC);
+        let primitive_dt = PrimitiveDateTime::new(utc_dt.date(), utc_dt.time());
+
+        Encode::<MySql>::encode(&primitive_dt, buf);
+    }
+}
+
+impl Decode<MySql> for OffsetDateTime {
+    fn decode(buf: &[u8]) -> Result<Self, DecodeError> {
+        let primitive: PrimitiveDateTime = Decode::<MySql>::decode(buf)?;
+
+        Ok(primitive.assume_utc())
+    }
+}
+
+impl HasSqlType<Time> for MySql {
+    fn type_info() -> MySqlTypeInfo {
+        MySqlTypeInfo::new(TypeId::TIME)
+    }
+}
+
+impl Encode<MySql> for Time {
+    fn encode(&self, buf: &mut Vec<u8>) {
+        let len = Encode::<MySql>::size_hint(self) - 1;
+        buf.push(len as u8);
+
+        // NaiveTime is not negative
+        buf.push(0);
+
+        // "date on 4 bytes little-endian format" (?)
+        // https://mariadb.com/kb/en/resultset-row/#teimstamp-binary-encoding
+        buf.advance(4);
+
+        encode_time(self, len > 9, buf);
+    }
+
+    fn size_hint(&self) -> usize {
+        if self.nanosecond() == 0 {
+            // if micro_seconds is 0, length is 8 and micro_seconds is not sent
+            9
+        } else {
+            // otherwise length is 12
+            13
+        }
+    }
+}
+
+impl Decode<MySql> for Time {
+    fn decode(mut buf: &[u8]) -> Result<Self, DecodeError> {
+        // data length, expecting 8 or 12 (fractional seconds)
+        let len = buf.get_u8()?;
+
+        // is negative : int<1>
+        let is_negative = buf.get_u8()?;
+        assert_eq!(is_negative, 0, "Negative dates/times are not supported");
+
+        // "date on 4 bytes little-endian format" (?)
+        // https://mariadb.com/kb/en/resultset-row/#timestamp-binary-encoding
+        buf.advance(4);
+
+        decode_time(len - 5, buf)
+    }
+}
+
+impl HasSqlType<Date> for MySql {
+    fn type_info() -> MySqlTypeInfo {
+        MySqlTypeInfo::new(TypeId::DATE)
+    }
+}
+
+impl Encode<MySql> for Date {
+    fn encode(&self, buf: &mut Vec<u8>) {
+        buf.push(4);
+
+        encode_date(self, buf);
+    }
+
+    fn size_hint(&self) -> usize {
+        5
+    }
+}
+
+impl Decode<MySql> for Date {
+    fn decode(buf: &[u8]) -> Result<Self, DecodeError> {
+        decode_date(&buf[1..])
+    }
+}
+
+impl HasSqlType<PrimitiveDateTime> for MySql {
+    fn type_info() -> MySqlTypeInfo {
+        MySqlTypeInfo::new(TypeId::DATETIME)
+    }
+}
+
+impl Encode<MySql> for PrimitiveDateTime {
+    fn encode(&self, buf: &mut Vec<u8>) {
+        let len = Encode::<MySql>::size_hint(self) - 1;
+        buf.push(len as u8);
+
+        encode_date(&self.date(), buf);
+
+        if len > 4 {
+            encode_time(&self.time(), len > 8, buf);
+        }
+    }
+
+    fn size_hint(&self) -> usize {
+        // to save space the packet can be compressed:
+        match (
+            self.hour(),
+            self.minute(),
+            self.second(),
+            self.nanosecond(),
+        ) {
+            // if hour, minutes, seconds and micro_seconds are all 0,
+            // length is 4 and no other field is sent
+            (0, 0, 0, 0) => 5,
+
+            // if micro_seconds is 0, length is 7
+            // and micro_seconds is not sent
+            (_, _, _, 0) => 8,
+
+            // otherwise length is 11
+            (_, _, _, _) => 12,
+        }
+    }
+}
+
+impl Decode<MySql> for PrimitiveDateTime {
+    fn decode(buf: &[u8]) -> Result<Self, DecodeError> {
+        let len = buf[0];
+        let date = decode_date(&buf[1..])?;
+
+        let dt = if len > 4 {
+            date.with_time(decode_time(len - 4, &buf[5..])?)
+        } else {
+            date.midnight()
+        };
+
+        Ok(dt)
+    }
+}
+
+fn encode_date(date: &Date, buf: &mut Vec<u8>) {
+    // MySQL supports years from 1000 - 9999
+    let year = u16::try_from(date.year())
+        .unwrap_or_else(|_| panic!("NaiveDateTime out of range for Mysql: {}", date));
+
+    buf.extend_from_slice(&year.to_le_bytes());
+    buf.push(date.month());
+    buf.push(date.day());
+}
+
+fn decode_date(buf: &[u8]) -> Result<Date, DecodeError> {
+    Date::try_from_ymd(
+        LittleEndian::read_u16(buf) as i32,
+        buf[2] as u8,
+        buf[3] as u8,
+    ).map_err(|e| DecodeError::Message(Box::new(format!("Error while decoding Date: {}", e))))
+}
+
+fn encode_time(time: &Time, include_micros: bool, buf: &mut Vec<u8>) {
+    buf.push(time.hour());
+    buf.push(time.minute());
+    buf.push(time.second());
+
+    if include_micros {
+        buf.put_u32::<LittleEndian>((time.nanosecond() / 1000) as u32);
+    }
+}
+
+fn decode_time(len: u8, mut buf: &[u8]) -> Result<Time, DecodeError> {
+    let hour = buf.get_u8()?;
+    let minute = buf.get_u8()?;
+    let seconds = buf.get_u8()?;
+
+    let micros = if len > 3 {
+        // microseconds : int<EOF>
+        buf.get_uint::<LittleEndian>(buf.len())?
+    } else {
+        0
+    };
+
+    Time::try_from_hms_micro(
+        hour,
+        minute,
+        seconds,
+        micros as u32,
+    ).map_err(|e| DecodeError::Message(Box::new(format!("Time out of range for MySQL: {}", e))))
+}
+
+#[cfg(test)]
+use time::{date, time};
+
+#[test]
+fn test_encode_date_time() {
+    let mut buf = Vec::new();
+
+    // test values from https://dev.mysql.com/doc/internals/en/binary-protocol-value.html
+    let date = PrimitiveDateTime::new(
+        date!(2010-10-17),
+        time!(19:27:30.000001),
+    );
+    Encode::<MySql>::encode(&date, &mut buf);
+    assert_eq!(*buf, [11, 218, 7, 10, 17, 19, 27, 30, 1, 0, 0, 0]);
+
+    buf.clear();
+
+    let date = PrimitiveDateTime::new(
+        date!(2010-10-17),
+        time!(19:27:30),
+    );
+    Encode::<MySql>::encode(&date, &mut buf);
+    assert_eq!(*buf, [7, 218, 7, 10, 17, 19, 27, 30]);
+
+    buf.clear();
+
+    let date = PrimitiveDateTime::new(
+        date!(2010-10-17),
+        time!(00:00:00),
+    );
+    Encode::<MySql>::encode(&date, &mut buf);
+    assert_eq!(*buf, [4, 218, 7, 10, 17]);
+}
+
+#[test]
+fn test_decode_date_time() {
+    // test values from https://dev.mysql.com/doc/internals/en/binary-protocol-value.html
+    let buf = [11, 218, 7, 10, 17, 19, 27, 30, 1, 0, 0, 0];
+    let date1 = <PrimitiveDateTime as Decode<MySql>>::decode(&buf).unwrap();
+    assert_eq!(date1.to_string(), "2010-10-17 19:27:30.000001");
+
+    let buf = [7, 218, 7, 10, 17, 19, 27, 30];
+    let date2 = <PrimitiveDateTime as Decode<MySql>>::decode(&buf).unwrap();
+    assert_eq!(date2.to_string(), "2010-10-17 19:27:30");
+
+    let buf = [4, 218, 7, 10, 17];
+    let date3 = <PrimitiveDateTime as Decode<MySql>>::decode(&buf).unwrap();
+    assert_eq!(date3.to_string(), "2010-10-17 0:00");
+}
+
+#[test]
+fn test_encode_date() {
+    let mut buf = Vec::new();
+    let date: Date = date!(2010-10-17);
+    Encode::<MySql>::encode(&date, &mut buf);
+    assert_eq!(*buf, [4, 218, 7, 10, 17]);
+}
+
+#[test]
+fn test_decode_date() {
+    let buf = [4, 218, 7, 10, 17];
+    let date = <Date as Decode<MySql>>::decode(&buf).unwrap();
+    assert_eq!(date, date!(2010-10-17));
+}
diff --git a/sqlx-core/src/postgres/types/mod.rs b/sqlx-core/src/postgres/types/mod.rs
index 28404d8b..2ca6a375 100644
--- a/sqlx-core/src/postgres/types/mod.rs
+++ b/sqlx-core/src/postgres/types/mod.rs
@@ -7,6 +7,9 @@ mod str;
 #[cfg(feature = "chrono")]
 mod chrono;
 
+#[cfg(feature = "time")]
+mod time;
+
 #[cfg(feature = "uuid")]
 mod uuid;
 
diff --git a/sqlx-core/src/postgres/types/time.rs b/sqlx-core/src/postgres/types/time.rs
new file mode 100644
index 00000000..5350022a
--- /dev/null
+++ b/sqlx-core/src/postgres/types/time.rs
@@ -0,0 +1,286 @@
+use std::convert::TryInto;
+use std::mem;
+
+use time::{date, offset, Date, Time, PrimitiveDateTime, OffsetDateTime, NumericalDuration};
+
+use crate::decode::{Decode, DecodeError};
+use crate::encode::Encode;
+use crate::postgres::protocol::TypeId;
+use crate::postgres::types::PgTypeInfo;
+use crate::postgres::Postgres;
+use crate::types::HasSqlType;
+
+const POSTGRES_EPOCH: PrimitiveDateTime = date!(2000-1-1).midnight();
+
+impl HasSqlType<Time> for Postgres {
+    fn type_info() -> PgTypeInfo {
+        PgTypeInfo::new(TypeId::TIME)
+    }
+}
+
+impl HasSqlType<Date> for Postgres {
+    fn type_info() -> PgTypeInfo {
+        PgTypeInfo::new(TypeId::DATE)
+    }
+}
+
+impl HasSqlType<PrimitiveDateTime> for Postgres {
+    fn type_info() -> PgTypeInfo {
+        PgTypeInfo::new(TypeId::TIMESTAMP)
+    }
+}
+
+impl HasSqlType<OffsetDateTime> for Postgres {
+    fn type_info() -> PgTypeInfo {
+        PgTypeInfo::new(TypeId::TIMESTAMPTZ)
+    }
+}
+
+impl HasSqlType<[Time]> for Postgres {
+    fn type_info() -> PgTypeInfo {
+        PgTypeInfo::new(TypeId::ARRAY_TIME)
+    }
+}
+
+impl HasSqlType<[Date]> for Postgres {
+    fn type_info() -> PgTypeInfo {
+        PgTypeInfo::new(TypeId::ARRAY_DATE)
+    }
+}
+
+impl HasSqlType<[PrimitiveDateTime]> for Postgres {
+    fn type_info() -> PgTypeInfo {
+        PgTypeInfo::new(TypeId::ARRAY_TIMESTAMP)
+    }
+}
+
+impl HasSqlType<[OffsetDateTime]> for Postgres {
+    fn type_info() -> PgTypeInfo {
+        PgTypeInfo::new(TypeId::ARRAY_TIMESTAMPTZ)
+    }
+}
+
+const fn microseconds_since_midnight(time: &Time) -> u64 {
+    time.hour() as u64 * 60 * 60 * 1_000_000
+        + time.minute() as u64 * 60 * 1_000_000
+        + time.second() as u64 * 1_000_000
+        + time.microsecond() as u64
+}
+
+fn from_nanoseconds_since_midnight(mut microsecond: u64) -> Result<Time, DecodeError> {
+    #![allow(clippy::cast_possible_truncation)]
+
+    microsecond %= 86_400 * 1_000_000;
+
+    Time::try_from_hms_micro(
+        (microsecond / 1_000_000 / 60 / 60) as u8,
+        (microsecond / 1_000_000 / 60 % 60) as u8,
+        (microsecond / 1_000_000 % 60) as u8,
+        (microsecond % 1_000_000) as u32,
+    ).map_err(|e| DecodeError::Message(Box::new(format!("Time out of range for Postgres: {}", e))))
+}
+
+impl Decode<Postgres> for Time {
+    fn decode(raw: &[u8]) -> Result<Self, DecodeError> {
+        let micros: i64 = Decode::<Postgres>::decode(raw)?;
+
+        from_nanoseconds_since_midnight(micros as u64)
+    }
+}
+
+impl Encode<Postgres> for Time {
+    fn encode(&self, buf: &mut Vec<u8>) {
+        let micros = microseconds_since_midnight(&self) / 1000;
+
+        Encode::<Postgres>::encode(&(micros as i64), buf);
+    }
+
+    fn size_hint(&self) -> usize {
+        mem::size_of::<u64>()
+    }
+}
+
+impl Decode<Postgres> for Date {
+    fn decode(raw: &[u8]) -> Result<Self, DecodeError> {
+        let n: i32 = Decode::<Postgres>::decode(raw)?;
+
+        Ok(date!(2000-1-1) + (n as i64).days())
+    }
+}
+
+impl Encode<Postgres> for Date {
+    fn encode(&self, buf: &mut Vec<u8>) {
+        let days: i32 = (*self - date!(2000-1-1))
+            .whole_days()
+            .try_into()
+            // TODO: How does Diesel handle this?
+            .unwrap_or_else(|_| panic!("Date out of range for Postgres: {:?}", self));
+
+        Encode::<Postgres>::encode(&days, buf)
+    }
+
+    fn size_hint(&self) -> usize {
+        mem::size_of::<i32>()
+    }
+}
+
+impl Decode<Postgres> for PrimitiveDateTime {
+    fn decode(raw: &[u8]) -> Result<Self, DecodeError> {
+        let n: i64 = Decode::<Postgres>::decode(raw)?;
+
+        Ok(POSTGRES_EPOCH + n.microseconds())
+    }
+}
+
+impl Encode<Postgres> for PrimitiveDateTime {
+    fn encode(&self, buf: &mut Vec<u8>) {
+        let micros: i64 = (*self - POSTGRES_EPOCH)
+            .whole_microseconds()
+            .try_into()
+            .unwrap_or_else(|_| panic!("PrimitiveDateTime out of range for Postgres: {:?}", self));
+
+        Encode::<Postgres>::encode(&micros, buf);
+    }
+
+    fn size_hint(&self) -> usize {
+        mem::size_of::<i64>()
+    }
+}
+
+impl Decode<Postgres> for OffsetDateTime {
+    fn decode(raw: &[u8]) -> Result<Self, DecodeError> {
+        let date_time: PrimitiveDateTime = Decode::<Postgres>::decode(raw)?;
+        Ok(date_time.assume_utc())
+    }
+}
+
+impl Encode<Postgres> for OffsetDateTime {
+    fn encode(&self, buf: &mut Vec<u8>) {
+        let utc_dt = self.to_offset(offset!(UTC));
+        let primitive_dt = PrimitiveDateTime::new(utc_dt.date(), utc_dt.time());
+
+        Encode::<Postgres>::encode(&primitive_dt, buf);
+    }
+
+    fn size_hint(&self) -> usize {
+        mem::size_of::<i64>()
+    }
+}
+
+#[cfg(test)]
+use time::time;
+
+#[test]
+fn test_encode_datetime() {
+    let mut buf = Vec::new();
+
+    Encode::<Postgres>::encode(&POSTGRES_EPOCH, &mut buf);
+    assert_eq!(buf, [0; 8]);
+    buf.clear();
+
+    // one hour past epoch
+    let date = POSTGRES_EPOCH + 1.hours();
+    Encode::<Postgres>::encode(&date, &mut buf);
+    assert_eq!(buf, 3_600_000_000i64.to_be_bytes());
+    buf.clear();
+
+    // some random date
+    let date = PrimitiveDateTime::new(date!(2019-12-11), time!(11:01:05));
+    let expected = (date - POSTGRES_EPOCH)
+        .whole_microseconds() as i64;
+    Encode::<Postgres>::encode(&date, &mut buf);
+    assert_eq!(buf, expected.to_be_bytes());
+    buf.clear();
+}
+
+#[test]
+fn test_decode_datetime() {
+    let buf = [0u8; 8];
+    let date: PrimitiveDateTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, PrimitiveDateTime::new(date!(2000-01-01), time!(00:00:00)));
+
+    let buf = 3_600_000_000i64.to_be_bytes();
+    let date: PrimitiveDateTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, PrimitiveDateTime::new(date!(2000-01-01), time!(01:00:00)));
+
+    let buf = 629_377_265_000_000i64.to_be_bytes();
+    let date: PrimitiveDateTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, PrimitiveDateTime::new(date!(2019-12-11), time!(11:01:05)));
+}
+
+
+#[test]
+fn test_encode_offsetdatetime() {
+    let mut buf = Vec::new();
+
+    Encode::<Postgres>::encode(&POSTGRES_EPOCH.assume_utc(), &mut buf);
+    assert_eq!(buf, [0; 8]);
+    buf.clear();
+
+    // one hour past epoch in MSK (2 hours before epoch in UTC)
+    let date = (POSTGRES_EPOCH + 1.hours()).assume_offset(offset!(+3));
+    Encode::<Postgres>::encode(&date, &mut buf);
+    assert_eq!(buf, (-7_200_000_000i64).to_be_bytes());
+    buf.clear();
+
+    // some random date in MSK
+    let date = PrimitiveDateTime::new(
+        date!(2019-12-11), time!(11:01:05)
+    ).assume_offset(offset!(+3));
+    let expected = (date - POSTGRES_EPOCH.assume_utc())
+        .whole_microseconds() as i64;
+    Encode::<Postgres>::encode(&date, &mut buf);
+    assert_eq!(buf, expected.to_be_bytes());
+    buf.clear();
+}
+
+#[test]
+fn test_decode_offsetdatetime() {
+    let buf = [0u8; 8];
+    let date: OffsetDateTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, PrimitiveDateTime::new(date!(2000-01-01), time!(00:00:00)).assume_utc());
+
+    let buf = 3_600_000_000i64.to_be_bytes();
+    let date: OffsetDateTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, PrimitiveDateTime::new(date!(2000-01-01), time!(01:00:00)).assume_utc());
+
+    let buf = 629_377_265_000_000i64.to_be_bytes();
+    let date: OffsetDateTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, PrimitiveDateTime::new(date!(2019-12-11), time!(11:01:05)).assume_utc());
+}
+
+#[test]
+fn test_encode_date() {
+    let mut buf = Vec::new();
+
+    let date = date!(2000-1-1);
+    Encode::<Postgres>::encode(&date, &mut buf);
+    assert_eq!(buf, [0; 4]);
+    buf.clear();
+
+    let date = date!(2001-1-1);
+    Encode::<Postgres>::encode(&date, &mut buf);
+    // 2000 was a leap year
+    assert_eq!(buf, 366i32.to_be_bytes());
+    buf.clear();
+
+    let date = date!(2019-12-11);
+    Encode::<Postgres>::encode(&date, &mut buf);
+    assert_eq!(buf, 7284i32.to_be_bytes());
+    buf.clear();
+}
+
+#[test]
+fn test_decode_date() {
+    let buf = [0; 4];
+    let date: Date = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, date!(2000-01-01));
+
+    let buf = 366i32.to_be_bytes();
+    let date: Date = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, date!(2001-01-01));
+
+    let buf = 7284i32.to_be_bytes();
+    let date: Date = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(date, date!(2019-12-11));
+}
diff --git a/sqlx-core/src/types.rs b/sqlx-core/src/types.rs
index b8371a94..d8a76161 100644
--- a/sqlx-core/src/types.rs
+++ b/sqlx-core/src/types.rs
@@ -14,6 +14,12 @@ pub mod chrono {
     pub use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
 }
 
+#[cfg(feature = "time")]
+#[cfg_attr(docsrs, doc(cfg(feature = "time")))]
+pub mod time {
+    pub use time::{Date, Time, PrimitiveDateTime, OffsetDateTime, UtcOffset};
+}
+
 pub trait TypeInfo: Debug + Display + Clone {
     /// Compares type information to determine if `other` is compatible at the Rust level
     /// with `self`.
diff --git a/sqlx-macros/Cargo.toml b/sqlx-macros/Cargo.toml
index d372a829..8d77398a 100644
--- a/sqlx-macros/Cargo.toml
+++ b/sqlx-macros/Cargo.toml
@@ -27,6 +27,7 @@ postgres = [ "sqlx/postgres" ]
 
 # type
 chrono = [ "sqlx/chrono" ]
+time = [ "sqlx/time" ]
 uuid = [ "sqlx/uuid" ]
 
 [dependencies]
diff --git a/sqlx-macros/src/database/mysql.rs b/sqlx-macros/src/database/mysql.rs
index e49a07bd..c766618d 100644
--- a/sqlx-macros/src/database/mysql.rs
+++ b/sqlx-macros/src/database/mysql.rs
@@ -17,17 +17,29 @@ impl_database_ext! {
         // BINARY, VAR_BINARY, BLOB
         Vec<u8>,
 
-        #[cfg(feature = "chrono")]
+        #[cfg(all(feature = "chrono", not(feature = "time")))]
         sqlx::types::chrono::NaiveTime,
 
-        #[cfg(feature = "chrono")]
+        #[cfg(all(feature = "chrono", not(feature = "time")))]
         sqlx::types::chrono::NaiveDate,
 
-        #[cfg(feature = "chrono")]
+        #[cfg(all(feature = "chrono", not(feature = "time")))]
         sqlx::types::chrono::NaiveDateTime,
 
-        #[cfg(feature = "chrono")]
+        #[cfg(all(feature = "chrono", not(feature = "time")))]
         sqlx::types::chrono::DateTime<sqlx::types::chrono::Utc>,
+
+        #[cfg(feature = "time")]
+        sqlx::types::time::Time,
+
+        #[cfg(feature = "time")]
+        sqlx::types::time::Date,
+
+        #[cfg(feature = "time")]
+        sqlx::types::time::PrimitiveDateTime,
+
+        #[cfg(feature = "time")]
+        sqlx::types::time::OffsetDateTime,
     },
     ParamChecking::Weak
 }
diff --git a/sqlx-macros/src/database/postgres.rs b/sqlx-macros/src/database/postgres.rs
index dcace458..65272fb3 100644
--- a/sqlx-macros/src/database/postgres.rs
+++ b/sqlx-macros/src/database/postgres.rs
@@ -14,17 +14,29 @@ impl_database_ext! {
         #[cfg(feature = "uuid")]
         sqlx::types::Uuid,
 
-        #[cfg(feature = "chrono")]
+        #[cfg(all(feature = "chrono", not(feature = "time")))]
         sqlx::types::chrono::NaiveTime,
 
-        #[cfg(feature = "chrono")]
+        #[cfg(all(feature = "chrono", not(feature = "time")))]
         sqlx::types::chrono::NaiveDate,
 
-        #[cfg(feature = "chrono")]
+        #[cfg(all(feature = "chrono", not(feature = "time")))]
         sqlx::types::chrono::NaiveDateTime,
 
-        #[cfg(feature = "chrono")]
+        #[cfg(all(feature = "chrono", not(feature = "time")))]
         sqlx::types::chrono::DateTime<sqlx::types::chrono::Utc> | sqlx::types::chrono::DateTime<_>,
+
+        #[cfg(feature = "time")]
+        sqlx::types::time::Time,
+
+        #[cfg(feature = "time")]
+        sqlx::types::time::Date,
+
+        #[cfg(feature = "time")]
+        sqlx::types::time::PrimitiveDateTime,
+
+        #[cfg(feature = "time")]
+        sqlx::types::time::OffsetDateTime,
     },
     ParamChecking::Strong
 }
diff --git a/tests/mysql-types-chrono.rs b/tests/mysql-types-chrono.rs
index 72a148a2..f57616e9 100644
--- a/tests/mysql-types-chrono.rs
+++ b/tests/mysql-types-chrono.rs
@@ -5,6 +5,7 @@ async fn connect() -> anyhow::Result<MySqlConnection> {
     Ok(MySqlConnection::open(dotenv::var("DATABASE_URL")?).await?)
 }
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_date() -> anyhow::Result<()> {
@@ -26,6 +27,7 @@ async fn mysql_chrono_date() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_date_time() -> anyhow::Result<()> {
@@ -45,6 +47,7 @@ async fn mysql_chrono_date_time() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_time() -> anyhow::Result<()> {
@@ -63,6 +66,7 @@ async fn mysql_chrono_time() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_timestamp() -> anyhow::Result<()> {
diff --git a/tests/mysql-types-time.rs b/tests/mysql-types-time.rs
new file mode 100644
index 00000000..5229c7ad
--- /dev/null
+++ b/tests/mysql-types-time.rs
@@ -0,0 +1,92 @@
+use sqlx::types::time::{OffsetDateTime, Date, Time, UtcOffset};
+use sqlx::{mysql::MySqlConnection, Connection, Row};
+
+async fn connect() -> anyhow::Result<MySqlConnection> {
+    Ok(MySqlConnection::open(dotenv::var("DATABASE_URL")?).await?)
+}
+
+#[cfg_attr(feature = "runtime-async-std", async_std::test)]
+#[cfg_attr(feature = "runtime-tokio", tokio::test)]
+async fn mysql_timers_date() -> anyhow::Result<()> {
+    let mut conn = connect().await?;
+
+    // TODO: maybe use macro here? but is it OK to include `time` as test dependency?
+    let value = Date::try_from_ymd(2019, 1, 2).unwrap();
+
+    let row = sqlx::query!(
+        "SELECT (DATE '2019-01-02' = ?) as _1, CAST(? AS DATE) as _2",
+        value,
+        value
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(row._1 != 0);
+    assert_eq!(value, row._2);
+
+    Ok(())
+}
+
+#[cfg_attr(feature = "runtime-async-std", async_std::test)]
+#[cfg_attr(feature = "runtime-tokio", tokio::test)]
+async fn mysql_timers_date_time() -> anyhow::Result<()> {
+    let mut conn = connect().await?;
+
+    let value = Date::try_from_ymd(2019, 1, 2)
+        .unwrap()
+        .try_with_hms(5, 10, 20)
+        .unwrap();
+
+    let row = sqlx::query("SELECT '2019-01-02 05:10:20' = ?, ?")
+        .bind(&value)
+        .bind(&value)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(row.get::<bool, _>(0));
+    assert_eq!(value, row.get(1));
+
+    Ok(())
+}
+
+#[cfg_attr(feature = "runtime-async-std", async_std::test)]
+#[cfg_attr(feature = "runtime-tokio", tokio::test)]
+async fn mysql_timers_time() -> anyhow::Result<()> {
+    let mut conn = connect().await?;
+
+    let value = Time::try_from_hms_micro(5, 10, 20, 115100).unwrap();
+
+    let row = sqlx::query("SELECT TIME '05:10:20.115100' = ?, TIME '05:10:20.115100'")
+        .bind(&value)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(row.get::<bool, _>(0));
+    assert_eq!(value, row.get(1));
+
+    Ok(())
+}
+
+#[cfg_attr(feature = "runtime-async-std", async_std::test)]
+#[cfg_attr(feature = "runtime-tokio", tokio::test)]
+async fn mysql_timers_timestamp() -> anyhow::Result<()> {
+    let mut conn = connect().await?;
+
+    let value = Date::try_from_ymd(2019, 1, 2)
+        .unwrap()
+        .try_with_hms_micro(5, 10, 20, 115100)
+        .unwrap()
+        .assume_utc();
+
+    let row = sqlx::query(
+        "SELECT TIMESTAMP '2019-01-02 05:10:20.115100' = ?, TIMESTAMP '2019-01-02 05:10:20.115100'",
+    )
+    .bind(&value)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(row.get::<bool, _>(0));
+    assert_eq!(value, row.get(1));
+
+    Ok(())
+}
diff --git a/tests/postgres-types-chrono.rs b/tests/postgres-types-chrono.rs
index 49b168ae..5fbb4fb7 100644
--- a/tests/postgres-types-chrono.rs
+++ b/tests/postgres-types-chrono.rs
@@ -5,6 +5,7 @@ async fn connect() -> anyhow::Result<PgConnection> {
     Ok(PgConnection::open(dotenv::var("DATABASE_URL")?).await?)
 }
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn postgres_chrono_date() -> anyhow::Result<()> {
@@ -23,6 +24,7 @@ async fn postgres_chrono_date() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_date_time() -> anyhow::Result<()> {
@@ -41,6 +43,7 @@ async fn mysql_chrono_date_time() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn postgres_chrono_time() -> anyhow::Result<()> {
@@ -59,6 +62,7 @@ async fn postgres_chrono_time() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn postgres_chrono_timestamp_tz() -> anyhow::Result<()> {
diff --git a/tests/postgres-types-time.rs b/tests/postgres-types-time.rs
new file mode 100644
index 00000000..05fa3a73
--- /dev/null
+++ b/tests/postgres-types-time.rs
@@ -0,0 +1,108 @@
+use sqlx::types::time::{OffsetDateTime, Date, Time, UtcOffset};
+use sqlx::{Connection, PgConnection, Row};
+
+async fn connect() -> anyhow::Result<PgConnection> {
+    Ok(PgConnection::open(dotenv::var("DATABASE_URL")?).await?)
+}
+
+#[cfg_attr(feature = "runtime-async-std", async_std::test)]
+#[cfg_attr(feature = "runtime-tokio", tokio::test)]
+async fn postgres_timers_date() -> anyhow::Result<()> {
+    let mut conn = connect().await?;
+
+    let value = Date::try_from_ymd(2019, 1, 2).unwrap();
+
+    let row = sqlx::query("SELECT DATE '2019-01-02' = $1, $1")
+        .bind(&value)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(row.get::<bool, _>(0));
+    assert_eq!(value, row.get(1));
+
+    Ok(())
+}
+
+#[cfg_attr(feature = "runtime-async-std", async_std::test)]
+#[cfg_attr(feature = "runtime-tokio", tokio::test)]
+async fn mysql_timers_date_time() -> anyhow::Result<()> {
+    let mut conn = connect().await?;
+
+    let value = Date::try_from_ymd(2019, 1, 2)
+        .unwrap()
+        .try_with_hms(5, 10, 20)
+        .unwrap();
+
+    let row = sqlx::query("SELECT '2019-01-02 05:10:20' = $1, $1")
+        .bind(&value)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(row.get::<bool, _>(0));
+    assert_eq!(value, row.get(1));
+
+    Ok(())
+}
+
+#[cfg_attr(feature = "runtime-async-std", async_std::test)]
+#[cfg_attr(feature = "runtime-tokio", tokio::test)]
+async fn postgres_timers_time() -> anyhow::Result<()> {
+    let mut conn = connect().await?;
+
+    let value = Time::try_from_hms_micro(5, 10, 20, 115100).unwrap();
+
+    let row = sqlx::query("SELECT TIME '05:10:20.115100' = $1, TIME '05:10:20.115100'")
+        .bind(&value)
+        .fetch_one(&mut conn)
+        .await?;
+
+    // FIXME: line 60 fails, while assertion on line 61 holds true (???)
+    // assert!(row.get::<bool, _>(0));
+    assert_eq!(value, row.get(1));
+
+    Ok(())
+}
+
+#[cfg_attr(feature = "runtime-async-std", async_std::test)]
+#[cfg_attr(feature = "runtime-tokio", tokio::test)]
+async fn postgres_timers_timestamp_tz() -> anyhow::Result<()> {
+    let mut conn = connect().await?;
+
+    let value = Date::try_from_ymd(2019, 1, 2)
+        .unwrap()
+        .try_with_hms_micro(5, 10, 20, 115100)
+        .unwrap()
+        .assume_utc();
+
+    let row = sqlx::query(
+        "SELECT TIMESTAMPTZ '2019-01-02 05:10:20.115100' = $1, TIMESTAMPTZ '2019-01-02 05:10:20.115100'",
+    )
+    .bind(&value)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(row.get::<bool, _>(0));
+
+    let out: OffsetDateTime = row.get(1);
+    assert_eq!(value, out);
+
+    let value = Date::try_from_ymd(2019, 1, 2)
+        .unwrap()
+        .try_with_hms_micro(5, 10, 20, 115100)
+        .unwrap()
+        .assume_offset(UtcOffset::east_hours(3));
+
+    let row = sqlx::query(
+        "SELECT TIMESTAMPTZ '2019-01-02 02:10:20.115100' = $1, TIMESTAMPTZ '2019-01-02 02:10:20.115100'",
+    )
+    .bind(&value)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(row.get::<bool, _>(0));
+
+    let out: OffsetDateTime = row.get(1);
+    assert_eq!(value, out);
+
+    Ok(())
+}

From 1975486baa493660658452da3152073180543a1a Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Sun, 1 Mar 2020 00:05:14 +0300
Subject: [PATCH 2/9] cargo fmt

---
 sqlx-core/src/mysql/types/time.rs    | 39 +++++-----------
 sqlx-core/src/postgres/types/time.rs | 67 +++++++++++++++++-----------
 sqlx-core/src/types.rs               |  2 +-
 tests/mysql-types-time.rs            |  2 +-
 tests/postgres-types-time.rs         |  2 +-
 5 files changed, 55 insertions(+), 57 deletions(-)

diff --git a/sqlx-core/src/mysql/types/time.rs b/sqlx-core/src/mysql/types/time.rs
index 201ee58a..151d6e9c 100644
--- a/sqlx-core/src/mysql/types/time.rs
+++ b/sqlx-core/src/mysql/types/time.rs
@@ -1,7 +1,7 @@
 use std::convert::TryFrom;
 
 use byteorder::{ByteOrder, LittleEndian};
-use time::{Date, Time, PrimitiveDateTime, OffsetDateTime, UtcOffset};
+use time::{Date, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};
 
 use crate::decode::{Decode, DecodeError};
 use crate::encode::Encode;
@@ -127,12 +127,7 @@ impl Encode<MySql> for PrimitiveDateTime {
 
     fn size_hint(&self) -> usize {
         // to save space the packet can be compressed:
-        match (
-            self.hour(),
-            self.minute(),
-            self.second(),
-            self.nanosecond(),
-        ) {
+        match (self.hour(), self.minute(), self.second(), self.nanosecond()) {
             // if hour, minutes, seconds and micro_seconds are all 0,
             // length is 4 and no other field is sent
             (0, 0, 0, 0) => 5,
@@ -177,7 +172,8 @@ fn decode_date(buf: &[u8]) -> Result<Date, DecodeError> {
         LittleEndian::read_u16(buf) as i32,
         buf[2] as u8,
         buf[3] as u8,
-    ).map_err(|e| DecodeError::Message(Box::new(format!("Error while decoding Date: {}", e))))
+    )
+    .map_err(|e| DecodeError::Message(Box::new(format!("Error while decoding Date: {}", e))))
 }
 
 fn encode_time(time: &Time, include_micros: bool, buf: &mut Vec<u8>) {
@@ -202,12 +198,8 @@ fn decode_time(len: u8, mut buf: &[u8]) -> Result<Time, DecodeError> {
         0
     };
 
-    Time::try_from_hms_micro(
-        hour,
-        minute,
-        seconds,
-        micros as u32,
-    ).map_err(|e| DecodeError::Message(Box::new(format!("Time out of range for MySQL: {}", e))))
+    Time::try_from_hms_micro(hour, minute, seconds, micros as u32)
+        .map_err(|e| DecodeError::Message(Box::new(format!("Time out of range for MySQL: {}", e))))
 }
 
 #[cfg(test)]
@@ -218,28 +210,19 @@ fn test_encode_date_time() {
     let mut buf = Vec::new();
 
     // test values from https://dev.mysql.com/doc/internals/en/binary-protocol-value.html
-    let date = PrimitiveDateTime::new(
-        date!(2010-10-17),
-        time!(19:27:30.000001),
-    );
+    let date = PrimitiveDateTime::new(date!(2010 - 10 - 17), time!(19:27:30.000001));
     Encode::<MySql>::encode(&date, &mut buf);
     assert_eq!(*buf, [11, 218, 7, 10, 17, 19, 27, 30, 1, 0, 0, 0]);
 
     buf.clear();
 
-    let date = PrimitiveDateTime::new(
-        date!(2010-10-17),
-        time!(19:27:30),
-    );
+    let date = PrimitiveDateTime::new(date!(2010 - 10 - 17), time!(19:27:30));
     Encode::<MySql>::encode(&date, &mut buf);
     assert_eq!(*buf, [7, 218, 7, 10, 17, 19, 27, 30]);
 
     buf.clear();
 
-    let date = PrimitiveDateTime::new(
-        date!(2010-10-17),
-        time!(00:00:00),
-    );
+    let date = PrimitiveDateTime::new(date!(2010 - 10 - 17), time!(00:00:00));
     Encode::<MySql>::encode(&date, &mut buf);
     assert_eq!(*buf, [4, 218, 7, 10, 17]);
 }
@@ -263,7 +246,7 @@ fn test_decode_date_time() {
 #[test]
 fn test_encode_date() {
     let mut buf = Vec::new();
-    let date: Date = date!(2010-10-17);
+    let date: Date = date!(2010 - 10 - 17);
     Encode::<MySql>::encode(&date, &mut buf);
     assert_eq!(*buf, [4, 218, 7, 10, 17]);
 }
@@ -272,5 +255,5 @@ fn test_encode_date() {
 fn test_decode_date() {
     let buf = [4, 218, 7, 10, 17];
     let date = <Date as Decode<MySql>>::decode(&buf).unwrap();
-    assert_eq!(date, date!(2010-10-17));
+    assert_eq!(date, date!(2010 - 10 - 17));
 }
diff --git a/sqlx-core/src/postgres/types/time.rs b/sqlx-core/src/postgres/types/time.rs
index 5350022a..6e1de699 100644
--- a/sqlx-core/src/postgres/types/time.rs
+++ b/sqlx-core/src/postgres/types/time.rs
@@ -1,7 +1,7 @@
 use std::convert::TryInto;
 use std::mem;
 
-use time::{date, offset, Date, Time, PrimitiveDateTime, OffsetDateTime, NumericalDuration};
+use time::{date, offset, Date, NumericalDuration, OffsetDateTime, PrimitiveDateTime, Time};
 
 use crate::decode::{Decode, DecodeError};
 use crate::encode::Encode;
@@ -10,7 +10,7 @@ use crate::postgres::types::PgTypeInfo;
 use crate::postgres::Postgres;
 use crate::types::HasSqlType;
 
-const POSTGRES_EPOCH: PrimitiveDateTime = date!(2000-1-1).midnight();
+const POSTGRES_EPOCH: PrimitiveDateTime = date!(2000 - 1 - 1).midnight();
 
 impl HasSqlType<Time> for Postgres {
     fn type_info() -> PgTypeInfo {
@@ -77,7 +77,8 @@ fn from_nanoseconds_since_midnight(mut microsecond: u64) -> Result<Time, DecodeE
         (microsecond / 1_000_000 / 60 % 60) as u8,
         (microsecond / 1_000_000 % 60) as u8,
         (microsecond % 1_000_000) as u32,
-    ).map_err(|e| DecodeError::Message(Box::new(format!("Time out of range for Postgres: {}", e))))
+    )
+    .map_err(|e| DecodeError::Message(Box::new(format!("Time out of range for Postgres: {}", e))))
 }
 
 impl Decode<Postgres> for Time {
@@ -104,13 +105,13 @@ impl Decode<Postgres> for Date {
     fn decode(raw: &[u8]) -> Result<Self, DecodeError> {
         let n: i32 = Decode::<Postgres>::decode(raw)?;
 
-        Ok(date!(2000-1-1) + (n as i64).days())
+        Ok(date!(2000 - 1 - 1) + (n as i64).days())
     }
 }
 
 impl Encode<Postgres> for Date {
     fn encode(&self, buf: &mut Vec<u8>) {
-        let days: i32 = (*self - date!(2000-1-1))
+        let days: i32 = (*self - date!(2000 - 1 - 1))
             .whole_days()
             .try_into()
             // TODO: How does Diesel handle this?
@@ -185,9 +186,8 @@ fn test_encode_datetime() {
     buf.clear();
 
     // some random date
-    let date = PrimitiveDateTime::new(date!(2019-12-11), time!(11:01:05));
-    let expected = (date - POSTGRES_EPOCH)
-        .whole_microseconds() as i64;
+    let date = PrimitiveDateTime::new(date!(2019 - 12 - 11), time!(11:01:05));
+    let expected = (date - POSTGRES_EPOCH).whole_microseconds() as i64;
     Encode::<Postgres>::encode(&date, &mut buf);
     assert_eq!(buf, expected.to_be_bytes());
     buf.clear();
@@ -197,18 +197,26 @@ fn test_encode_datetime() {
 fn test_decode_datetime() {
     let buf = [0u8; 8];
     let date: PrimitiveDateTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, PrimitiveDateTime::new(date!(2000-01-01), time!(00:00:00)));
+    assert_eq!(
+        date,
+        PrimitiveDateTime::new(date!(2000 - 01 - 01), time!(00:00:00))
+    );
 
     let buf = 3_600_000_000i64.to_be_bytes();
     let date: PrimitiveDateTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, PrimitiveDateTime::new(date!(2000-01-01), time!(01:00:00)));
+    assert_eq!(
+        date,
+        PrimitiveDateTime::new(date!(2000 - 01 - 01), time!(01:00:00))
+    );
 
     let buf = 629_377_265_000_000i64.to_be_bytes();
     let date: PrimitiveDateTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, PrimitiveDateTime::new(date!(2019-12-11), time!(11:01:05)));
+    assert_eq!(
+        date,
+        PrimitiveDateTime::new(date!(2019 - 12 - 11), time!(11:01:05))
+    );
 }
 
-
 #[test]
 fn test_encode_offsetdatetime() {
     let mut buf = Vec::new();
@@ -224,11 +232,9 @@ fn test_encode_offsetdatetime() {
     buf.clear();
 
     // some random date in MSK
-    let date = PrimitiveDateTime::new(
-        date!(2019-12-11), time!(11:01:05)
-    ).assume_offset(offset!(+3));
-    let expected = (date - POSTGRES_EPOCH.assume_utc())
-        .whole_microseconds() as i64;
+    let date =
+        PrimitiveDateTime::new(date!(2019 - 12 - 11), time!(11:01:05)).assume_offset(offset!(+3));
+    let expected = (date - POSTGRES_EPOCH.assume_utc()).whole_microseconds() as i64;
     Encode::<Postgres>::encode(&date, &mut buf);
     assert_eq!(buf, expected.to_be_bytes());
     buf.clear();
@@ -238,33 +244,42 @@ fn test_encode_offsetdatetime() {
 fn test_decode_offsetdatetime() {
     let buf = [0u8; 8];
     let date: OffsetDateTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, PrimitiveDateTime::new(date!(2000-01-01), time!(00:00:00)).assume_utc());
+    assert_eq!(
+        date,
+        PrimitiveDateTime::new(date!(2000 - 01 - 01), time!(00:00:00)).assume_utc()
+    );
 
     let buf = 3_600_000_000i64.to_be_bytes();
     let date: OffsetDateTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, PrimitiveDateTime::new(date!(2000-01-01), time!(01:00:00)).assume_utc());
+    assert_eq!(
+        date,
+        PrimitiveDateTime::new(date!(2000 - 01 - 01), time!(01:00:00)).assume_utc()
+    );
 
     let buf = 629_377_265_000_000i64.to_be_bytes();
     let date: OffsetDateTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, PrimitiveDateTime::new(date!(2019-12-11), time!(11:01:05)).assume_utc());
+    assert_eq!(
+        date,
+        PrimitiveDateTime::new(date!(2019 - 12 - 11), time!(11:01:05)).assume_utc()
+    );
 }
 
 #[test]
 fn test_encode_date() {
     let mut buf = Vec::new();
 
-    let date = date!(2000-1-1);
+    let date = date!(2000 - 1 - 1);
     Encode::<Postgres>::encode(&date, &mut buf);
     assert_eq!(buf, [0; 4]);
     buf.clear();
 
-    let date = date!(2001-1-1);
+    let date = date!(2001 - 1 - 1);
     Encode::<Postgres>::encode(&date, &mut buf);
     // 2000 was a leap year
     assert_eq!(buf, 366i32.to_be_bytes());
     buf.clear();
 
-    let date = date!(2019-12-11);
+    let date = date!(2019 - 12 - 11);
     Encode::<Postgres>::encode(&date, &mut buf);
     assert_eq!(buf, 7284i32.to_be_bytes());
     buf.clear();
@@ -274,13 +289,13 @@ fn test_encode_date() {
 fn test_decode_date() {
     let buf = [0; 4];
     let date: Date = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, date!(2000-01-01));
+    assert_eq!(date, date!(2000 - 01 - 01));
 
     let buf = 366i32.to_be_bytes();
     let date: Date = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, date!(2001-01-01));
+    assert_eq!(date, date!(2001 - 01 - 01));
 
     let buf = 7284i32.to_be_bytes();
     let date: Date = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(date, date!(2019-12-11));
+    assert_eq!(date, date!(2019 - 12 - 11));
 }
diff --git a/sqlx-core/src/types.rs b/sqlx-core/src/types.rs
index d8a76161..ee5083ff 100644
--- a/sqlx-core/src/types.rs
+++ b/sqlx-core/src/types.rs
@@ -17,7 +17,7 @@ pub mod chrono {
 #[cfg(feature = "time")]
 #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
 pub mod time {
-    pub use time::{Date, Time, PrimitiveDateTime, OffsetDateTime, UtcOffset};
+    pub use time::{Date, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};
 }
 
 pub trait TypeInfo: Debug + Display + Clone {
diff --git a/tests/mysql-types-time.rs b/tests/mysql-types-time.rs
index 5229c7ad..f438da9c 100644
--- a/tests/mysql-types-time.rs
+++ b/tests/mysql-types-time.rs
@@ -1,4 +1,4 @@
-use sqlx::types::time::{OffsetDateTime, Date, Time, UtcOffset};
+use sqlx::types::time::{Date, OffsetDateTime, Time, UtcOffset};
 use sqlx::{mysql::MySqlConnection, Connection, Row};
 
 async fn connect() -> anyhow::Result<MySqlConnection> {
diff --git a/tests/postgres-types-time.rs b/tests/postgres-types-time.rs
index 05fa3a73..49eab49f 100644
--- a/tests/postgres-types-time.rs
+++ b/tests/postgres-types-time.rs
@@ -1,4 +1,4 @@
-use sqlx::types::time::{OffsetDateTime, Date, Time, UtcOffset};
+use sqlx::types::time::{Date, OffsetDateTime, Time, UtcOffset};
 use sqlx::{Connection, PgConnection, Row};
 
 async fn connect() -> anyhow::Result<PgConnection> {

From 322393c9ee04b4851ebb234e0756fc54227acfc3 Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Sun, 1 Mar 2020 11:57:32 +0300
Subject: [PATCH 3/9] [fix] revert default features

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index af92747f..06c07667 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ features = [ "tls", "postgres", "mysql", "uuid", "chrono", "time" ]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
-default = [ "macros", "runtime-async-std", "time", "postgres" ]
+default = [ "macros", "runtime-async-std" ]
 macros = [ "sqlx-macros" ]
 tls = [ "sqlx-core/tls" ]
 

From b2f50de16f149b5868b87f7a3abb1c82f8b73023 Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Sun, 1 Mar 2020 13:20:24 +0300
Subject: [PATCH 4/9] review fixes: change test attributes, fix tests, add time
 encoding-decoding tests

---
 sqlx-core/src/postgres/types/chrono.rs | 61 +++++++++++++++++++
 sqlx-core/src/postgres/types/time.rs   | 81 +++++++++++++++++++++++---
 tests/mysql-types-chrono.rs            |  3 -
 tests/postgres-types-chrono.rs         | 16 +++--
 tests/postgres-types-time.rs           | 14 ++---
 5 files changed, 147 insertions(+), 28 deletions(-)

diff --git a/sqlx-core/src/postgres/types/chrono.rs b/sqlx-core/src/postgres/types/chrono.rs
index d73d1d89..38f82194 100644
--- a/sqlx-core/src/postgres/types/chrono.rs
+++ b/sqlx-core/src/postgres/types/chrono.rs
@@ -173,6 +173,67 @@ fn postgres_epoch() -> DateTime<Utc> {
     Utc.ymd(2000, 1, 1).and_hms(0, 0, 0)
 }
 
+#[test]
+fn test_encode_time() {
+    let mut buf = Vec::new();
+
+    Encode::<Postgres>::encode(&NaiveTime::from_hms(0, 0, 0), &mut buf);
+    assert_eq!(buf, [0; 8]);
+    buf.clear();
+
+    // one second
+    Encode::<Postgres>::encode(&NaiveTime::from_hms(0, 0, 1), &mut buf);
+    assert_eq!(buf, 1_000_000i64.to_be_bytes());
+    buf.clear();
+
+    // two hours
+    Encode::<Postgres>::encode(&NaiveTime::from_hms(2, 0, 0), &mut buf);
+    let expected = 1_000_000i64 * 60 * 60 * 2;
+    assert_eq!(buf, expected.to_be_bytes());
+    buf.clear();
+
+    // 3:14:15.000001
+    Encode::<Postgres>::encode(&NaiveTime::from_hms_micro(3, 14, 15, 1), &mut buf);
+    let expected =
+        1_000_000i64 * 60 * 60 * 3 +
+        1_000_000i64 * 60 * 14 +
+        1_000_000i64 * 15 +
+        1
+    ;
+    assert_eq!(buf, expected.to_be_bytes());
+    buf.clear();
+}
+#[test]
+fn test_decode_time() {
+    let buf = [0u8; 8];
+    let time: NaiveTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(
+        time,
+        NaiveTime::from_hms(0, 0, 0),
+    );
+
+    // half an hour
+    let buf = (1_000_000i64 * 60 * 30).to_be_bytes();
+    let time: NaiveTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(
+        time,
+        NaiveTime::from_hms(0, 30, 0),
+    );
+
+    // 12:53:05.125305
+    let buf = (
+        1_000_000i64 * 60 * 60 * 12 +
+        1_000_000i64 * 60 * 53 +
+        1_000_000i64 * 5 +
+        125305
+    ).to_be_bytes();
+    let time: NaiveTime = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(
+        time,
+        NaiveTime::from_hms_micro(12, 53, 5, 125305),
+    );
+}
+
 #[test]
 fn test_encode_datetime() {
     let mut buf = Vec::new();
diff --git a/sqlx-core/src/postgres/types/time.rs b/sqlx-core/src/postgres/types/time.rs
index 6e1de699..60690ae5 100644
--- a/sqlx-core/src/postgres/types/time.rs
+++ b/sqlx-core/src/postgres/types/time.rs
@@ -60,14 +60,14 @@ impl HasSqlType<[OffsetDateTime]> for Postgres {
     }
 }
 
-const fn microseconds_since_midnight(time: &Time) -> u64 {
-    time.hour() as u64 * 60 * 60 * 1_000_000
-        + time.minute() as u64 * 60 * 1_000_000
-        + time.second() as u64 * 1_000_000
-        + time.microsecond() as u64
+fn microseconds_since_midnight(time: Time) -> i64 {
+    time.hour() as i64 * 60 * 60 * 1_000_000
+        + time.minute() as i64 * 60 * 1_000_000
+        + time.second() as i64 * 1_000_000
+        + time.microsecond() as i64
 }
 
-fn from_nanoseconds_since_midnight(mut microsecond: u64) -> Result<Time, DecodeError> {
+fn from_microseconds_since_midnight(mut microsecond: u64) -> Result<Time, DecodeError> {
     #![allow(clippy::cast_possible_truncation)]
 
     microsecond %= 86_400 * 1_000_000;
@@ -85,15 +85,15 @@ impl Decode<Postgres> for Time {
     fn decode(raw: &[u8]) -> Result<Self, DecodeError> {
         let micros: i64 = Decode::<Postgres>::decode(raw)?;
 
-        from_nanoseconds_since_midnight(micros as u64)
+        from_microseconds_since_midnight(micros as u64)
     }
 }
 
 impl Encode<Postgres> for Time {
     fn encode(&self, buf: &mut Vec<u8>) {
-        let micros = microseconds_since_midnight(&self) / 1000;
+        let micros = microseconds_since_midnight(*self);
 
-        Encode::<Postgres>::encode(&(micros as i64), buf);
+        Encode::<Postgres>::encode(&(micros), buf);
     }
 
     fn size_hint(&self) -> usize {
@@ -171,6 +171,69 @@ impl Encode<Postgres> for OffsetDateTime {
 #[cfg(test)]
 use time::time;
 
+#[test]
+fn test_encode_time() {
+    let mut buf = Vec::new();
+
+    Encode::<Postgres>::encode(&time!(0:00), &mut buf);
+    assert_eq!(buf, [0; 8]);
+    buf.clear();
+
+    // one second
+    Encode::<Postgres>::encode(&time!(0:00:01), &mut buf);
+    assert_eq!(buf, 1_000_000i64.to_be_bytes());
+    buf.clear();
+
+    // two hours
+    Encode::<Postgres>::encode(&time!(2:00), &mut buf);
+    let expected = 1_000_000i64 * 60 * 60 * 2;
+    assert_eq!(buf, expected.to_be_bytes());
+    buf.clear();
+
+    // 3:14:15.000001
+    Encode::<Postgres>::encode(&time!(3:14:15.000001), &mut buf);
+    let expected =
+        1_000_000i64 * 60 * 60 * 3 +
+        1_000_000i64 * 60 * 14 +
+        1_000_000i64 * 15 +
+        1
+    ;
+    assert_eq!(buf, expected.to_be_bytes());
+    buf.clear();
+}
+
+
+#[test]
+fn test_decode_time() {
+    let buf = [0u8; 8];
+    let time: Time = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(
+        time,
+        time!(0:00),
+    );
+
+    // half an hour
+    let buf = (1_000_000i64 * 60 * 30).to_be_bytes();
+    let time: Time = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(
+        time,
+        time!(0:30),
+    );
+
+    // 12:53:05.125305
+    let buf = (
+        1_000_000i64 * 60 * 60 * 12 +
+        1_000_000i64 * 60 * 53 +
+        1_000_000i64 * 5 +
+        125305
+    ).to_be_bytes();
+    let time: Time = Decode::<Postgres>::decode(&buf).unwrap();
+    assert_eq!(
+        time,
+        time!(12:53:05.125305),
+    );
+}
+
 #[test]
 fn test_encode_datetime() {
     let mut buf = Vec::new();
diff --git a/tests/mysql-types-chrono.rs b/tests/mysql-types-chrono.rs
index f57616e9..77a26f94 100644
--- a/tests/mysql-types-chrono.rs
+++ b/tests/mysql-types-chrono.rs
@@ -27,7 +27,6 @@ async fn mysql_chrono_date() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_date_time() -> anyhow::Result<()> {
@@ -47,7 +46,6 @@ async fn mysql_chrono_date_time() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_time() -> anyhow::Result<()> {
@@ -66,7 +64,6 @@ async fn mysql_chrono_time() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_timestamp() -> anyhow::Result<()> {
diff --git a/tests/postgres-types-chrono.rs b/tests/postgres-types-chrono.rs
index 5fbb4fb7..063473c9 100644
--- a/tests/postgres-types-chrono.rs
+++ b/tests/postgres-types-chrono.rs
@@ -5,7 +5,6 @@ async fn connect() -> anyhow::Result<PgConnection> {
     Ok(PgConnection::open(dotenv::var("DATABASE_URL")?).await?)
 }
 
-#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn postgres_chrono_date() -> anyhow::Result<()> {
@@ -24,7 +23,6 @@ async fn postgres_chrono_date() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn mysql_chrono_date_time() -> anyhow::Result<()> {
@@ -51,18 +49,18 @@ async fn postgres_chrono_time() -> anyhow::Result<()> {
 
     let value = NaiveTime::from_hms_micro(5, 10, 20, 115100);
 
-    let row = sqlx::query("SELECT TIME '05:10:20.115100' = $1, TIME '05:10:20.115100'")
-        .bind(&value)
-        .fetch_one(&mut conn)
-        .await?;
+    let row = sqlx::query!(
+        "SELECT TIME '05:10:20.115100' = $1 AS equality, TIME '05:10:20.115100' AS time"
+    )
+    .fetch_one(&mut conn)
+    .await?;
 
-    assert!(row.get::<bool, _>(0));
-    assert_eq!(value, row.get(1));
+    assert!(row.equality);
+    assert_eq!(value, row.time);
 
     Ok(())
 }
 
-#[cfg(all(feature = "chrono", not(feature = "time")))]
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
 async fn postgres_chrono_timestamp_tz() -> anyhow::Result<()> {
diff --git a/tests/postgres-types-time.rs b/tests/postgres-types-time.rs
index 49eab49f..bad41572 100644
--- a/tests/postgres-types-time.rs
+++ b/tests/postgres-types-time.rs
@@ -51,14 +51,14 @@ async fn postgres_timers_time() -> anyhow::Result<()> {
 
     let value = Time::try_from_hms_micro(5, 10, 20, 115100).unwrap();
 
-    let row = sqlx::query("SELECT TIME '05:10:20.115100' = $1, TIME '05:10:20.115100'")
-        .bind(&value)
-        .fetch_one(&mut conn)
-        .await?;
+    let row = sqlx::query!(
+        "SELECT TIME '05:10:20.115100' = $1 AS equality, TIME '05:10:20.115100' AS time", value
+    )
+    .fetch_one(&mut conn)
+    .await?;
 
-    // FIXME: line 60 fails, while assertion on line 61 holds true (???)
-    // assert!(row.get::<bool, _>(0));
-    assert_eq!(value, row.get(1));
+    assert!(row.equality);
+    assert_eq!(value, row.time);
 
     Ok(())
 }

From 0656c880cca76463641b88ab3005abee70dc4ce7 Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Sun, 1 Mar 2020 13:23:33 +0300
Subject: [PATCH 5/9] cargo fmt

---
 sqlx-core/src/postgres/types/chrono.rs | 30 +++++--------------------
 sqlx-core/src/postgres/types/time.rs   | 31 +++++---------------------
 tests/postgres-types-time.rs           |  3 ++-
 3 files changed, 14 insertions(+), 50 deletions(-)

diff --git a/sqlx-core/src/postgres/types/chrono.rs b/sqlx-core/src/postgres/types/chrono.rs
index 38f82194..4451cf79 100644
--- a/sqlx-core/src/postgres/types/chrono.rs
+++ b/sqlx-core/src/postgres/types/chrono.rs
@@ -194,12 +194,7 @@ fn test_encode_time() {
 
     // 3:14:15.000001
     Encode::<Postgres>::encode(&NaiveTime::from_hms_micro(3, 14, 15, 1), &mut buf);
-    let expected =
-        1_000_000i64 * 60 * 60 * 3 +
-        1_000_000i64 * 60 * 14 +
-        1_000_000i64 * 15 +
-        1
-    ;
+    let expected = 1_000_000i64 * 60 * 60 * 3 + 1_000_000i64 * 60 * 14 + 1_000_000i64 * 15 + 1;
     assert_eq!(buf, expected.to_be_bytes());
     buf.clear();
 }
@@ -207,31 +202,18 @@ fn test_encode_time() {
 fn test_decode_time() {
     let buf = [0u8; 8];
     let time: NaiveTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(
-        time,
-        NaiveTime::from_hms(0, 0, 0),
-    );
+    assert_eq!(time, NaiveTime::from_hms(0, 0, 0),);
 
     // half an hour
     let buf = (1_000_000i64 * 60 * 30).to_be_bytes();
     let time: NaiveTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(
-        time,
-        NaiveTime::from_hms(0, 30, 0),
-    );
+    assert_eq!(time, NaiveTime::from_hms(0, 30, 0),);
 
     // 12:53:05.125305
-    let buf = (
-        1_000_000i64 * 60 * 60 * 12 +
-        1_000_000i64 * 60 * 53 +
-        1_000_000i64 * 5 +
-        125305
-    ).to_be_bytes();
+    let buf = (1_000_000i64 * 60 * 60 * 12 + 1_000_000i64 * 60 * 53 + 1_000_000i64 * 5 + 125305)
+        .to_be_bytes();
     let time: NaiveTime = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(
-        time,
-        NaiveTime::from_hms_micro(12, 53, 5, 125305),
-    );
+    assert_eq!(time, NaiveTime::from_hms_micro(12, 53, 5, 125305),);
 }
 
 #[test]
diff --git a/sqlx-core/src/postgres/types/time.rs b/sqlx-core/src/postgres/types/time.rs
index 60690ae5..4f2319f4 100644
--- a/sqlx-core/src/postgres/types/time.rs
+++ b/sqlx-core/src/postgres/types/time.rs
@@ -192,46 +192,27 @@ fn test_encode_time() {
 
     // 3:14:15.000001
     Encode::<Postgres>::encode(&time!(3:14:15.000001), &mut buf);
-    let expected =
-        1_000_000i64 * 60 * 60 * 3 +
-        1_000_000i64 * 60 * 14 +
-        1_000_000i64 * 15 +
-        1
-    ;
+    let expected = 1_000_000i64 * 60 * 60 * 3 + 1_000_000i64 * 60 * 14 + 1_000_000i64 * 15 + 1;
     assert_eq!(buf, expected.to_be_bytes());
     buf.clear();
 }
 
-
 #[test]
 fn test_decode_time() {
     let buf = [0u8; 8];
     let time: Time = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(
-        time,
-        time!(0:00),
-    );
+    assert_eq!(time, time!(0:00));
 
     // half an hour
     let buf = (1_000_000i64 * 60 * 30).to_be_bytes();
     let time: Time = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(
-        time,
-        time!(0:30),
-    );
+    assert_eq!(time, time!(0:30));
 
     // 12:53:05.125305
-    let buf = (
-        1_000_000i64 * 60 * 60 * 12 +
-        1_000_000i64 * 60 * 53 +
-        1_000_000i64 * 5 +
-        125305
-    ).to_be_bytes();
+    let buf = (1_000_000i64 * 60 * 60 * 12 + 1_000_000i64 * 60 * 53 + 1_000_000i64 * 5 + 125305)
+        .to_be_bytes();
     let time: Time = Decode::<Postgres>::decode(&buf).unwrap();
-    assert_eq!(
-        time,
-        time!(12:53:05.125305),
-    );
+    assert_eq!(time, time!(12:53:05.125305));
 }
 
 #[test]
diff --git a/tests/postgres-types-time.rs b/tests/postgres-types-time.rs
index bad41572..3e3089be 100644
--- a/tests/postgres-types-time.rs
+++ b/tests/postgres-types-time.rs
@@ -52,7 +52,8 @@ async fn postgres_timers_time() -> anyhow::Result<()> {
     let value = Time::try_from_hms_micro(5, 10, 20, 115100).unwrap();
 
     let row = sqlx::query!(
-        "SELECT TIME '05:10:20.115100' = $1 AS equality, TIME '05:10:20.115100' AS time", value
+        "SELECT TIME '05:10:20.115100' = $1 AS equality, TIME '05:10:20.115100' AS time",
+        value
     )
     .fetch_one(&mut conn)
     .await?;

From a3160d2bae495d81245abbf76976817b0c64a33b Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Sun, 1 Mar 2020 13:31:29 +0300
Subject: [PATCH 6/9] [fix] query usage in postgres ITs

---
 tests/postgres-types-chrono.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/postgres-types-chrono.rs b/tests/postgres-types-chrono.rs
index 063473c9..9cd85153 100644
--- a/tests/postgres-types-chrono.rs
+++ b/tests/postgres-types-chrono.rs
@@ -50,7 +50,8 @@ async fn postgres_chrono_time() -> anyhow::Result<()> {
     let value = NaiveTime::from_hms_micro(5, 10, 20, 115100);
 
     let row = sqlx::query!(
-        "SELECT TIME '05:10:20.115100' = $1 AS equality, TIME '05:10:20.115100' AS time"
+        "SELECT TIME '05:10:20.115100' = $1 AS equality, TIME '05:10:20.115100' AS time",
+        value,
     )
     .fetch_one(&mut conn)
     .await?;

From 2082ce15e5af29c6b94dd64d76eba4c7f1869b03 Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Sun, 1 Mar 2020 13:44:03 +0300
Subject: [PATCH 7/9] [fix] move one `use` behind the cfg-flag, as it is used
 conditionally

---
 tests/postgres-types-chrono.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/postgres-types-chrono.rs b/tests/postgres-types-chrono.rs
index 9cd85153..75deed4f 100644
--- a/tests/postgres-types-chrono.rs
+++ b/tests/postgres-types-chrono.rs
@@ -1,6 +1,9 @@
-use sqlx::types::chrono::{DateTime, NaiveDate, NaiveTime, Utc};
+use sqlx::types::chrono::{DateTime, NaiveDate, Utc};
 use sqlx::{Connection, PgConnection, Row};
 
+#[cfg(all(feature = "chrono", not(feature = "time")))]
+use sqlx::types::chrono::NaiveTime;
+
 async fn connect() -> anyhow::Result<PgConnection> {
     Ok(PgConnection::open(dotenv::var("DATABASE_URL")?).await?)
 }

From b785f83fc2b9e9d1cbc905da5a81f85f09671234 Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Sun, 1 Mar 2020 18:02:21 +0300
Subject: [PATCH 8/9] [fix] naming + unneeded cast

---
 sqlx-core/src/mysql/types/time.rs    | 4 ++--
 sqlx-core/src/postgres/types/time.rs | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/sqlx-core/src/mysql/types/time.rs b/sqlx-core/src/mysql/types/time.rs
index 151d6e9c..eee0c7a0 100644
--- a/sqlx-core/src/mysql/types/time.rs
+++ b/sqlx-core/src/mysql/types/time.rs
@@ -45,7 +45,7 @@ impl Encode<MySql> for Time {
         let len = Encode::<MySql>::size_hint(self) - 1;
         buf.push(len as u8);
 
-        // NaiveTime is not negative
+        // Time is not negative
         buf.push(0);
 
         // "date on 4 bytes little-endian format" (?)
@@ -160,7 +160,7 @@ impl Decode<MySql> for PrimitiveDateTime {
 fn encode_date(date: &Date, buf: &mut Vec<u8>) {
     // MySQL supports years from 1000 - 9999
     let year = u16::try_from(date.year())
-        .unwrap_or_else(|_| panic!("NaiveDateTime out of range for Mysql: {}", date));
+        .unwrap_or_else(|_| panic!("Date out of range for Mysql: {}", date));
 
     buf.extend_from_slice(&year.to_le_bytes());
     buf.push(date.month());
diff --git a/sqlx-core/src/postgres/types/time.rs b/sqlx-core/src/postgres/types/time.rs
index 4f2319f4..61535eba 100644
--- a/sqlx-core/src/postgres/types/time.rs
+++ b/sqlx-core/src/postgres/types/time.rs
@@ -93,7 +93,7 @@ impl Encode<Postgres> for Time {
     fn encode(&self, buf: &mut Vec<u8>) {
         let micros = microseconds_since_midnight(*self);
 
-        Encode::<Postgres>::encode(&(micros), buf);
+        Encode::<Postgres>::encode(&micros, buf);
     }
 
     fn size_hint(&self) -> usize {
@@ -105,7 +105,7 @@ impl Decode<Postgres> for Date {
     fn decode(raw: &[u8]) -> Result<Self, DecodeError> {
         let n: i32 = Decode::<Postgres>::decode(raw)?;
 
-        Ok(date!(2000 - 1 - 1) + (n as i64).days())
+        Ok(date!(2000 - 1 - 1) + n.days())
     }
 }
 

From 78362ccc416c945a5a76b0ba29fd7a41aaa4a84a Mon Sep 17 00:00:00 2001
From: Vlad Stepanov <8uk.8ak@gmail.com>
Date: Wed, 4 Mar 2020 22:11:46 +0300
Subject: [PATCH 9/9] update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f77de00a..0539db37 100644
--- a/README.md
+++ b/README.md
@@ -82,7 +82,7 @@ sqlx = { version = "0.2", default-features = false, features = [ "runtime-tokio"
 
  * `chrono`: Add support for date and time types from `chrono`.
 
- * `time`: Add support for date and time types from `time` crate (simpler than `chrono`)
+ * `time`: Add support for date and time types from `time` crate (alternative to `chrono`, prefered by `query!` macro, if both enabled)
 
  * `tls`: Add support for TLS connections.