diff options
Diffstat (limited to 'src/types/time.rs')
| -rw-r--r-- | src/types/time.rs | 148 |
1 files changed, 117 insertions, 31 deletions
diff --git a/src/types/time.rs b/src/types/time.rs index 8589167..4e2811e 100644 --- a/src/types/time.rs +++ b/src/types/time.rs @@ -1,15 +1,35 @@ -//! `ToSql` and `FromSql` implementation for [`time::OffsetDateTime`]. +//! [`ToSql`] and [`FromSql`] implementation for [`time::OffsetDateTime`]. use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; -use crate::Result; +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}; -const CURRENT_TIMESTAMP_FMT: &str = "%Y-%m-%d %H:%M:%S"; -const SQLITE_DATETIME_FMT: &str = "%Y-%m-%dT%H:%M:%S.%NZ"; -const SQLITE_DATETIME_FMT_LEGACY: &str = "%Y-%m-%d %H:%M:%S:%N %z"; +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!( + "[year]-[month]-[day] [hour]:[minute]:[second].[subsecond][offset_hour sign:mandatory]:[offset_minute]" +); +const LEGACY_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!( + "[year]-[month]-[day] [hour]:[minute]:[second]:[subsecond] [offset_hour sign:mandatory]:[offset_minute]" +); impl ToSql for OffsetDateTime { + #[inline] fn to_sql(&self) -> Result<ToSqlOutput<'_>> { - let time_string = self.to_offset(UtcOffset::UTC).format(SQLITE_DATETIME_FMT); + // FIXME keep original offset + let time_string = self + .to_offset(UtcOffset::UTC) + .format(&PRIMITIVE_DATE_TIME_Z_FORMAT) + .map_err(|err| Error::ToSqlConversionFailure(err.into()))?; Ok(ToSqlOutput::from(time_string)) } } @@ -17,13 +37,29 @@ impl ToSql for OffsetDateTime { 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' { + // YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM + return OffsetDateTime::parse(s, &Rfc3339) + .map_err(|err| FromSqlError::Other(Box::new(err))); + } + let s = s.strip_suffix('Z').unwrap_or(s); match s.len() { - 19 => PrimitiveDateTime::parse(s, CURRENT_TIMESTAMP_FMT).map(|d| d.assume_utc()), - _ => PrimitiveDateTime::parse(s, SQLITE_DATETIME_FMT) - .map(|d| d.assume_utc()) + 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| { - OffsetDateTime::parse(s, SQLITE_DATETIME_FMT_LEGACY).map_err(|_| err) + PrimitiveDateTime::parse(s, &PRIMITIVE_DATE_TIME_FORMAT) + .map(PrimitiveDateTime::assume_utc) + .map_err(|_| err) }), + _ => OffsetDateTime::parse(s, &OFFSET_SHORT_DATE_TIME_FORMAT), } .map_err(|err| FromSqlError::Other(Box::new(err))) }) @@ -32,25 +68,20 @@ impl FromSql for OffsetDateTime { #[cfg(test)] mod test { - use crate::{Connection, Result, NO_PARAMS}; - use std::time::Duration; + use crate::{Connection, Result}; + use time::format_description::well_known::Rfc3339; use time::OffsetDateTime; - fn checked_memory_handle() -> Connection { - let db = Connection::open_in_memory().unwrap(); - db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT)") - .unwrap(); - db - } - #[test] - fn test_offset_date_time() { - let db = checked_memory_handle(); + 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 mut ts_vec = vec![]; - let make_datetime = - |secs, nanos| OffsetDateTime::from_unix_timestamp(secs) + Duration::from_nanos(nanos); + let make_datetime = |secs: i128, nanos: i128| { + OffsetDateTime::from_unix_timestamp_nanos(1_000_000_000 * secs + nanos).unwrap() + }; ts_vec.push(make_datetime(10_000, 0)); //January 1, 1970 2:46:40 AM ts_vec.push(make_datetime(10_000, 1000)); //January 1, 1970 2:46:40 AM (and one microsecond) @@ -60,23 +91,78 @@ mod test { ts_vec.push(make_datetime(10_000_000_000, 0)); //November 20, 2286 for ts in ts_vec { - db.execute("INSERT INTO foo(t) VALUES (?)", &[&ts]).unwrap(); + db.execute("INSERT INTO foo(t) VALUES (?)", [ts])?; - let from: OffsetDateTime = db - .query_row("SELECT t FROM foo", NO_PARAMS, |r| r.get(0)) - .unwrap(); + let from: OffsetDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; - db.execute("DELETE FROM foo", NO_PARAMS).unwrap(); + db.execute("DELETE FROM foo", [])?; assert_eq!(from, ts); } + Ok(()) } #[test] - fn test_sqlite_functions() { - let db = checked_memory_handle(); + fn test_string_values() -> Result<()> { + let db = Connection::open_in_memory()?; + for (s, t) in vec![ + ( + "2013-10-07 08:23:19", + Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()), + ), + ( + "2013-10-07 08:23:19Z", + Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()), + ), + ( + "2013-10-07T08:23:19Z", + Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()), + ), + ( + "2013-10-07 08:23:19.120", + Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()), + ), + ( + "2013-10-07 08:23:19.120Z", + Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()), + ), + ( + "2013-10-07T08:23:19.120Z", + Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()), + ), + ( + "2013-10-07 04:23:19-04:00", + Ok(OffsetDateTime::parse("2013-10-07T04:23:19-04:00", &Rfc3339).unwrap()), + ), + ( + "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<OffsetDateTime> = db.query_row("SELECT ?", [s], |r| r.get(0)); + assert_eq!(result, t); + } + Ok(()) + } + + #[test] + fn test_sqlite_functions() -> Result<()> { + let db = Connection::open_in_memory()?; let result: Result<OffsetDateTime> = - db.query_row("SELECT CURRENT_TIMESTAMP", NO_PARAMS, |r| r.get(0)); + db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0)); + assert!(result.is_ok()); + Ok(()) + } + + #[test] + fn test_param() -> Result<()> { + let db = Connection::open_in_memory()?; + let result: Result<bool> = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [OffsetDateTime::now_utc()], |r| r.get(0)); assert!(result.is_ok()); + Ok(()) } } |