Merge pull request #1374 from nydrani/time-support

Implement support for more `time` types

README.md

@@ -113,8 +113,8 @@ features](https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-s
   and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for the
   `Value` type from the [`serde_json` crate](https://crates.io/crates/serde_json).
 * `time` implements [`FromSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.FromSql.html)
-   and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for the
+  and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for various
-   `time::OffsetDateTime` type from the [`time` crate](https://crates.io/crates/time).
+  types from the [`time` crate](https://crates.io/crates/time).
 * `url` implements [`FromSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.FromSql.html)
   and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for the
   `Url` type from the [`url` crate](https://crates.io/crates/url).

src/types/time.rs

@@ -1,81 +1,174 @@
+//! Convert formats 1-10 in [Time Values](https://sqlite.org/lang_datefunc.html#time_values) to time types.
 //! [`ToSql`] and [`FromSql`] implementation for [`time::OffsetDateTime`].
+//! [`ToSql`] and [`FromSql`] implementation for [`time::PrimitiveDateTime`].
+//! [`ToSql`] and [`FromSql`] implementation for [`time::Date`].
+//! [`ToSql`] and [`FromSql`] implementation for [`time::Time`].
+//! Time Strings in:
+//!  - Format 2: "YYYY-MM-DD HH:MM"
+//!  - Format 5: "YYYY-MM-DDTHH:MM"
+//!  - Format 8: "HH:MM"
+//! without an explicit second value will assume 0 seconds.
+//! Time String that contain an optional timezone without an explicit date are unsupported.
+//! All other assumptions described in [Time Values](https://sqlite.org/lang_datefunc.html#time_values) section are unsupported.
+
 use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
 use crate::{Error, Result};
-use time::format_description::well_known::Rfc3339;
 use time::format_description::FormatItem;
 use time::macros::format_description;
-use time::{OffsetDateTime, PrimitiveDateTime, UtcOffset};
+use time::{Date, OffsetDateTime, PrimitiveDateTime, Time};
 
-const PRIMITIVE_SHORT_DATE_TIME_FORMAT: &[FormatItem<'_>] =
+const OFFSET_DATE_TIME_ENCODING: &[FormatItem<'_>] = format_description!(
-    format_description!("[year]-[month]-[day] [hour]:[minute]:[second]");
+    version = 2,
-const PRIMITIVE_DATE_TIME_FORMAT: &[FormatItem<'_>] =
-    format_description!("[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]");
-const PRIMITIVE_DATE_TIME_Z_FORMAT: &[FormatItem<'_>] =
-    format_description!("[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]Z");
-const OFFSET_SHORT_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
-    "[year]-[month]-[day] [hour]:[minute]:[second][offset_hour sign:mandatory]:[offset_minute]"
-);
-const OFFSET_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
     "[year]-[month]-[day] [hour]:[minute]:[second].[subsecond][offset_hour sign:mandatory]:[offset_minute]"
 );
+const PRIMITIVE_DATE_TIME_ENCODING: &[FormatItem<'_>] = format_description!(
+    version = 2,
+    "[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]"
+);
+const TIME_ENCODING: &[FormatItem<'_>] =
+    format_description!(version = 2, "[hour]:[minute]:[second].[subsecond]");
+
+const DATE_FORMAT: &[FormatItem<'_>] = format_description!(version = 2, "[year]-[month]-[day]");
+const TIME_FORMAT: &[FormatItem<'_>] = format_description!(
+    version = 2,
+    "[hour]:[minute][optional [:[second][optional [.[subsecond]]]]]"
+);
+const PRIMITIVE_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
+    version = 2,
+    "[year]-[month]-[day][first [ ][T]][hour]:[minute][optional [:[second][optional [.[subsecond]]]]]"
+);
+const UTC_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
+    version = 2,
+    "[year]-[month]-[day][first [ ][T]][hour]:[minute][optional [:[second][optional [.[subsecond]]]]][optional [Z]]"
+);
+const OFFSET_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
+    version = 2,
+    "[year]-[month]-[day][first [ ][T]][hour]:[minute][optional [:[second][optional [.[subsecond]]]]][offset_hour sign:mandatory]:[offset_minute]"
+);
 const LEGACY_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
+    version = 2,
     "[year]-[month]-[day] [hour]:[minute]:[second]:[subsecond] [offset_hour sign:mandatory]:[offset_minute]"
 );
 
+/// OffsetDatetime => RFC3339 format ("YYYY-MM-DD HH:MM:SS.SSS[+-]HH:MM")
 impl ToSql for OffsetDateTime {
     #[inline]
     fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
-        // FIXME keep original offset
         let time_string = self
-            .to_offset(UtcOffset::UTC)
+            .format(&OFFSET_DATE_TIME_ENCODING)
-            .format(&PRIMITIVE_DATE_TIME_Z_FORMAT)
             .map_err(|err| Error::ToSqlConversionFailure(err.into()))?;
         Ok(ToSqlOutput::from(time_string))
     }
 }
 
+// Supports parsing formats 2-7 from https://www.sqlite.org/lang_datefunc.html
+// Formats 2-7 without a timezone assumes UTC
 impl FromSql for OffsetDateTime {
     fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
         value.as_str().and_then(|s| {
-            if s.len() > 10 && s.as_bytes()[10] == b'T' {
+            if let Some(b' ') = s.as_bytes().get(23) {
-                // YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM
+                // legacy
-                return OffsetDateTime::parse(s, &Rfc3339)
+                return OffsetDateTime::parse(s, &LEGACY_DATE_TIME_FORMAT)
                     .map_err(|err| FromSqlError::Other(Box::new(err)));
             }
-            let s = s.strip_suffix('Z').unwrap_or(s);
+            if s[8..].contains('+') || s[8..].contains('-') {
-            match s.len() {
+                // Formats 2-7 with timezone
-                len if len <= 19 => {
+                return OffsetDateTime::parse(s, &OFFSET_DATE_TIME_FORMAT)
-                    // TODO YYYY-MM-DDTHH:MM:SS
+                    .map_err(|err| FromSqlError::Other(Box::new(err)));
-                    PrimitiveDateTime::parse(s, &PRIMITIVE_SHORT_DATE_TIME_FORMAT)
-                        .map(PrimitiveDateTime::assume_utc)
-                }
-                _ if s.as_bytes()[19] == b':' => {
-                    // legacy
-                    OffsetDateTime::parse(s, &LEGACY_DATE_TIME_FORMAT)
-                }
-                _ if s.as_bytes()[19] == b'.' => OffsetDateTime::parse(s, &OFFSET_DATE_TIME_FORMAT)
-                    .or_else(|err| {
-                        PrimitiveDateTime::parse(s, &PRIMITIVE_DATE_TIME_FORMAT)
-                            .map(PrimitiveDateTime::assume_utc)
-                            .map_err(|_| err)
-                    }),
-                _ => OffsetDateTime::parse(s, &OFFSET_SHORT_DATE_TIME_FORMAT),
             }
+            // Formats 2-7 without timezone
+            PrimitiveDateTime::parse(s, &UTC_DATE_TIME_FORMAT)
+                .map(|p| p.assume_utc())
                 .map_err(|err| FromSqlError::Other(Box::new(err)))
         })
     }
 }
 
+/// ISO 8601 calendar date without timezone => "YYYY-MM-DD"
+impl ToSql for Date {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let date_str = self
+            .format(&DATE_FORMAT)
+            .map_err(|err| Error::ToSqlConversionFailure(err.into()))?;
+        Ok(ToSqlOutput::from(date_str))
+    }
+}
+
+/// "YYYY-MM-DD" => ISO 8601 calendar date without timezone.
+impl FromSql for Date {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().and_then(|s| {
+            Date::parse(s, &DATE_FORMAT).map_err(|err| FromSqlError::Other(err.into()))
+        })
+    }
+}
+
+/// ISO 8601 time without timezone => "HH:MM:SS.SSS"
+impl ToSql for Time {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let time_str = self
+            .format(&TIME_ENCODING)
+            .map_err(|err| Error::ToSqlConversionFailure(err.into()))?;
+        Ok(ToSqlOutput::from(time_str))
+    }
+}
+
+/// "HH:MM"/"HH:MM:SS"/"HH:MM:SS.SSS" => ISO 8601 time without timezone.
+impl FromSql for Time {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().and_then(|s| {
+            Time::parse(s, &TIME_FORMAT).map_err(|err| FromSqlError::Other(err.into()))
+        })
+    }
+}
+
+/// ISO 8601 combined date and time without timezone => "YYYY-MM-DD HH:MM:SS.SSS"
+impl ToSql for PrimitiveDateTime {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let date_time_str = self
+            .format(&PRIMITIVE_DATE_TIME_ENCODING)
+            .map_err(|err| Error::ToSqlConversionFailure(err.into()))?;
+        Ok(ToSqlOutput::from(date_time_str))
+    }
+}
+
+/// YYYY-MM-DD HH:MM
+/// YYYY-MM-DDTHH:MM
+/// YYYY-MM-DD HH:MM:SS
+/// YYYY-MM-DDTHH:MM:SS
+/// YYYY-MM-DD HH:MM:SS.SSS
+/// YYYY-MM-DDTHH:MM:SS.SSS
+/// => ISO 8601 combined date and time with timezone
+impl FromSql for PrimitiveDateTime {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().and_then(|s| {
+            PrimitiveDateTime::parse(s, &PRIMITIVE_DATE_TIME_FORMAT)
+                .map_err(|err| FromSqlError::Other(err.into()))
+        })
+    }
+}
+
 #[cfg(test)]
 mod test {
     use crate::{Connection, Result};
-    use time::format_description::well_known::Rfc3339;
+    use time::macros::{date, datetime, time};
-    use time::OffsetDateTime;
+    use time::{Date, OffsetDateTime, PrimitiveDateTime, Time};
+
+    fn checked_memory_handle() -> Result<Connection> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT, b BLOB)")?;
+        Ok(db)
+    }
 
     #[test]
     fn test_offset_date_time() -> Result<()> {
-        let db = Connection::open_in_memory()?;
+        let db = checked_memory_handle()?;
-        db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT)")?;
 
         let mut ts_vec = vec![];
 
@@ -103,47 +196,163 @@ mod test {
     }
 
     #[test]
-    fn test_string_values() -> Result<()> {
+    fn test_offset_date_time_parsing() -> Result<()> {
-        let db = Connection::open_in_memory()?;
+        let db = checked_memory_handle()?;
-        for (s, t) in vec![
+        let tests = vec![
+            // Rfc3339
             (
-                "2013-10-07 08:23:19",
+                "2013-10-07T08:23:19.123456789Z",
-                Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()),
+                datetime!(2013-10-07 8:23:19.123456789 UTC),
             ),
             (
-                "2013-10-07 08:23:19Z",
+                "2013-10-07 08:23:19.123456789Z",
-                Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()),
+                datetime!(2013-10-07 8:23:19.123456789 UTC),
+            ),
+            // Format 2
+            ("2013-10-07 08:23", datetime!(2013-10-07 8:23 UTC)),
+            ("2013-10-07 08:23Z", datetime!(2013-10-07 8:23 UTC)),
+            ("2013-10-07 08:23+04:00", datetime!(2013-10-07 8:23 +4)),
+            // Format 3
+            ("2013-10-07 08:23:19", datetime!(2013-10-07 8:23:19 UTC)),
+            ("2013-10-07 08:23:19Z", datetime!(2013-10-07 8:23:19 UTC)),
+            (
+                "2013-10-07 08:23:19+04:00",
+                datetime!(2013-10-07 8:23:19 +4),
+            ),
+            // Format 4
+            (
+                "2013-10-07 08:23:19.123",
+                datetime!(2013-10-07 8:23:19.123 UTC),
             ),
             (
-                "2013-10-07T08:23:19Z",
+                "2013-10-07 08:23:19.123Z",
-                Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()),
+                datetime!(2013-10-07 8:23:19.123 UTC),
             ),
             (
-                "2013-10-07 08:23:19.120",
+                "2013-10-07 08:23:19.123+04:00",
-                Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()),
+                datetime!(2013-10-07 8:23:19.123 +4),
+            ),
+            // Format 5
+            ("2013-10-07T08:23", datetime!(2013-10-07 8:23 UTC)),
+            ("2013-10-07T08:23Z", datetime!(2013-10-07 8:23 UTC)),
+            ("2013-10-07T08:23+04:00", datetime!(2013-10-07 8:23 +4)),
+            // Format 6
+            ("2013-10-07T08:23:19", datetime!(2013-10-07 8:23:19 UTC)),
+            ("2013-10-07T08:23:19Z", datetime!(2013-10-07 8:23:19 UTC)),
+            (
+                "2013-10-07T08:23:19+04:00",
+                datetime!(2013-10-07 8:23:19 +4),
+            ),
+            // Format 7
+            (
+                "2013-10-07T08:23:19.123",
+                datetime!(2013-10-07 8:23:19.123 UTC),
             ),
             (
-                "2013-10-07 08:23:19.120Z",
+                "2013-10-07T08:23:19.123Z",
-                Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()),
+                datetime!(2013-10-07 8:23:19.123 UTC),
             ),
             (
-                "2013-10-07T08:23:19.120Z",
+                "2013-10-07T08:23:19.123+04:00",
-                Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()),
+                datetime!(2013-10-07 8:23:19.123 +4),
             ),
+            // Legacy
             (
-                "2013-10-07 04:23:19-04:00",
+                "2013-10-07 08:23:12:987 -07:00",
-                Ok(OffsetDateTime::parse("2013-10-07T04:23:19-04:00", &Rfc3339).unwrap()),
+                datetime!(2013-10-07 8:23:12.987 -7),
             ),
-            (
+        ];
-                "2013-10-07 04:23:19.120-04:00",
+
-                Ok(OffsetDateTime::parse("2013-10-07T04:23:19.120-04:00", &Rfc3339).unwrap()),
+        for (s, t) in tests {
-            ),
+            let result: OffsetDateTime = db.query_row("SELECT ?1", [s], |r| r.get(0))?;
-            (
+            assert_eq!(result, t);
-                "2013-10-07T04:23:19.120-04:00",
+        }
-                Ok(OffsetDateTime::parse("2013-10-07T04:23:19.120-04:00", &Rfc3339).unwrap()),
+        Ok(())
-            ),
+    }
-        ] {
+
-            let result: Result<OffsetDateTime> = db.query_row("SELECT ?1", [s], |r| r.get(0));
+    #[test]
+    fn test_date() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let date = date!(2016 - 02 - 23);
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [date])?;
+
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!("2016-02-23", s);
+        let t: Date = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(date, t);
+        Ok(())
+    }
+
+    #[test]
+    fn test_time() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let time = time!(23:56:04.00001);
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [time])?;
+
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!("23:56:04.00001", s);
+        let v: Time = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(time, v);
+        Ok(())
+    }
+
+    #[test]
+    fn test_primitive_date_time() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let dt = date!(2016 - 02 - 23).with_time(time!(23:56:04));
+
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [dt])?;
+
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!("2016-02-23 23:56:04.0", s);
+        let v: PrimitiveDateTime = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(dt, v);
+
+        db.execute("UPDATE foo set b = datetime(t)", [])?; // "YYYY-MM-DD HH:MM:SS"
+        let hms: PrimitiveDateTime = db.one_column("SELECT b FROM foo")?;
+        assert_eq!(dt, hms);
+        Ok(())
+    }
+
+    #[test]
+    fn test_date_parsing() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let result: Date = db.query_row("SELECT ?1", ["2013-10-07"], |r| r.get(0))?;
+        assert_eq!(result, date!(2013 - 10 - 07));
+        Ok(())
+    }
+
+    #[test]
+    fn test_time_parsing() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let tests = vec![
+            ("08:23", time!(08:23)),
+            ("08:23:19", time!(08:23:19)),
+            ("08:23:19.111", time!(08:23:19.111)),
+        ];
+
+        for (s, t) in tests {
+            let result: Time = db.query_row("SELECT ?1", [s], |r| r.get(0))?;
+            assert_eq!(result, t);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_primitive_date_time_parsing() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        let tests = vec![
+            ("2013-10-07T08:23", datetime!(2013-10-07 8:23)),
+            ("2013-10-07T08:23:19", datetime!(2013-10-07 8:23:19)),
+            ("2013-10-07T08:23:19.111", datetime!(2013-10-07 8:23:19.111)),
+            ("2013-10-07 08:23", datetime!(2013-10-07 8:23)),
+            ("2013-10-07 08:23:19", datetime!(2013-10-07 8:23:19)),
+            ("2013-10-07 08:23:19.111", datetime!(2013-10-07 8:23:19.111)),
+        ];
+
+        for (s, t) in tests {
+            let result: PrimitiveDateTime = db.query_row("SELECT ?1", [s], |r| r.get(0))?;
             assert_eq!(result, t);
         }
         Ok(())
@@ -151,16 +360,66 @@ mod test {
 
     #[test]
     fn test_sqlite_functions() -> Result<()> {
-        let db = Connection::open_in_memory()?;
+        let db = checked_memory_handle()?;
-        let result: Result<OffsetDateTime> = db.one_column("SELECT CURRENT_TIMESTAMP");
+        db.one_column::<Time>("SELECT CURRENT_TIME").unwrap();
+        db.one_column::<Date>("SELECT CURRENT_DATE").unwrap();
+        db.one_column::<PrimitiveDateTime>("SELECT CURRENT_TIMESTAMP")
+            .unwrap();
+        db.one_column::<OffsetDateTime>("SELECT CURRENT_TIMESTAMP")
+            .unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_time_param() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let now = OffsetDateTime::now_utc().time();
+        let result: Result<bool> = db.query_row(
+            "SELECT 1 WHERE ?1 BETWEEN time('now', '-1 minute') AND time('now', '+1 minute')",
+            [now],
+            |r| r.get(0),
+        );
         result.unwrap();
         Ok(())
     }
 
     #[test]
-    fn test_param() -> Result<()> {
+    fn test_date_param() -> Result<()> {
-        let db = Connection::open_in_memory()?;
+        let db = checked_memory_handle()?;
-        let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [OffsetDateTime::now_utc()], |r| r.get(0));
+        let now = OffsetDateTime::now_utc().date();
+        let result: Result<bool> = db.query_row(
+            "SELECT 1 WHERE ?1 BETWEEN date('now', '-1 day') AND date('now', '+1 day')",
+            [now],
+            |r| r.get(0),
+        );
+        result.unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_primitive_date_time_param() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let now = PrimitiveDateTime::new(
+            OffsetDateTime::now_utc().date(),
+            OffsetDateTime::now_utc().time(),
+        );
+        let result: Result<bool> = db.query_row(
+            "SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')",
+            [now],
+            |r| r.get(0),
+        );
+        result.unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_offset_date_time_param() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let result: Result<bool> = db.query_row(
+            "SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')",
+            [OffsetDateTime::now_utc()],
+            |r| r.get(0),
+        );
         result.unwrap();
         Ok(())
     }