diff --git a/README.md b/README.md index 76013b8..dfed8dc 100644 --- a/README.md +++ b/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 - `time::OffsetDateTime` type from the [`time` crate](https://crates.io/crates/time). + and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for various + 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). diff --git a/src/types/time.rs b/src/types/time.rs index 03b2d61..265d6c6 100644 --- a/src/types/time.rs +++ b/src/types/time.rs @@ -1,67 +1,155 @@ +//! 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<'_>] = - format_description!("[year]-[month]-[day] [hour]:[minute]:[second]"); -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!( +const OFFSET_DATE_TIME_ENCODING: &[FormatItem<'_>] = format_description!( + version = 2, "[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> { - // FIXME keep original offset let time_string = self - .to_offset(UtcOffset::UTC) - .format(&PRIMITIVE_DATE_TIME_Z_FORMAT) + .format(&OFFSET_DATE_TIME_ENCODING) .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 { value.as_str().and_then(|s| { - if s.len() > 10 && s.as_bytes()[10] == b'T' { - // YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM - return OffsetDateTime::parse(s, &Rfc3339) + if let Some(b' ') = s.as_bytes().get(23) { + // legacy + 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); - match s.len() { - len if len <= 19 => { - // TODO YYYY-MM-DDTHH:MM:SS - 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), + if s[8..].contains('+') || s[8..].contains('-') { + // Formats 2-7 with timezone + return OffsetDateTime::parse(s, &OFFSET_DATE_TIME_FORMAT) + .map_err(|err| FromSqlError::Other(Box::new(err))); } - .map_err(|err| FromSqlError::Other(Box::new(err))) + // 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> { + 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 { + 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> { + 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 { + 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> { + 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 { + value.as_str().and_then(|s| { + PrimitiveDateTime::parse(s, &PRIMITIVE_DATE_TIME_FORMAT) + .map_err(|err| FromSqlError::Other(err.into())) }) } } @@ -69,13 +157,18 @@ impl FromSql for OffsetDateTime { #[cfg(test)] mod test { use crate::{Connection, Result}; - use time::format_description::well_known::Rfc3339; - use time::OffsetDateTime; + use time::macros::{date, datetime, time}; + use time::{Date, OffsetDateTime, PrimitiveDateTime, Time}; + + fn checked_memory_handle() -> Result { + 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()?; - db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT)")?; + let db = checked_memory_handle()?; let mut ts_vec = vec![]; @@ -103,47 +196,163 @@ mod test { } #[test] - fn test_string_values() -> Result<()> { - let db = Connection::open_in_memory()?; - for (s, t) in vec![ + fn test_offset_date_time_parsing() -> Result<()> { + let db = checked_memory_handle()?; + let tests = vec![ + // Rfc3339 ( - "2013-10-07 08:23:19", - Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()), + "2013-10-07T08:23:19.123456789Z", + datetime!(2013-10-07 8:23:19.123456789 UTC), ), ( - "2013-10-07 08:23:19Z", - Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()), + "2013-10-07 08:23:19.123456789Z", + 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", - Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()), + "2013-10-07 08:23:19.123Z", + datetime!(2013-10-07 8:23:19.123 UTC), ), ( - "2013-10-07 08:23:19.120", - Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()), + "2013-10-07 08:23:19.123+04:00", + 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", - Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()), + "2013-10-07T08:23:19.123Z", + datetime!(2013-10-07 8:23:19.123 UTC), ), ( - "2013-10-07T08:23:19.120Z", - Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()), + "2013-10-07T08:23:19.123+04:00", + datetime!(2013-10-07 8:23:19.123 +4), ), + // Legacy ( - "2013-10-07 04:23:19-04:00", - Ok(OffsetDateTime::parse("2013-10-07T04:23:19-04:00", &Rfc3339).unwrap()), + "2013-10-07 08:23:12:987 -07:00", + 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()), - ), - ( - "2013-10-07T04:23:19.120-04:00", - Ok(OffsetDateTime::parse("2013-10-07T04:23:19.120-04:00", &Rfc3339).unwrap()), - ), - ] { - let result: Result = db.query_row("SELECT ?1", [s], |r| r.get(0)); + ]; + + for (s, t) in tests { + let result: OffsetDateTime = db.query_row("SELECT ?1", [s], |r| r.get(0))?; + assert_eq!(result, t); + } + Ok(()) + } + + #[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 result: Result = db.one_column("SELECT CURRENT_TIMESTAMP"); + let db = checked_memory_handle()?; + db.one_column::