rusqlite/src/types/chrono.rs

231 lines
8.2 KiB
Rust
Raw Normal View History

2016-02-22 20:36:49 +01:00
//! Convert most of the [Time Strings](http://sqlite.org/lang_datefunc.html) to chrono types.
extern crate chrono;
use std::borrow::Cow;
2016-02-22 20:36:49 +01:00
use self::chrono::{NaiveDate, NaiveTime, NaiveDateTime, DateTime, TimeZone, UTC, Local};
use libc::c_int;
use types::{FromSql, FromSqlError, ToSql, ValueRef};
2016-02-22 20:36:49 +01:00
use ffi::sqlite3_stmt;
/// ISO 8601 calendar date without timezone => "YYYY-MM-DD"
impl ToSql for NaiveDate {
unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
let date_str = self.format("%Y-%m-%d").to_string();
date_str.bind_parameter(stmt, col)
}
}
/// "YYYY-MM-DD" => ISO 8601 calendar date without timezone.
2016-02-22 20:36:49 +01:00
impl FromSql for NaiveDate {
fn column_result(value: ValueRef) -> Result<Self, FromSqlError> {
value.as_str().and_then(|s| match NaiveDate::parse_from_str(s, "%Y-%m-%d") {
Ok(dt) => Ok(dt),
Err(err) => Err(FromSqlError::Other(Box::new(err))),
})
}
2016-02-22 20:36:49 +01:00
}
/// ISO 8601 time without timezone => "HH:MM:SS.SSS"
impl ToSql for NaiveTime {
unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
let date_str = self.format("%H:%M:%S%.f").to_string();
2016-02-22 20:36:49 +01:00
date_str.bind_parameter(stmt, col)
}
}
/// "HH:MM"/"HH:MM:SS"/"HH:MM:SS.SSS" => ISO 8601 time without timezone.
impl FromSql for NaiveTime {
fn column_result(value: ValueRef) -> Result<Self, FromSqlError> {
value.as_str().and_then(|s| {
let fmt = match s.len() {
5 => "%H:%M",
8 => "%H:%M:%S",
_ => "%H:%M:%S%.f",
};
match NaiveTime::parse_from_str(s, fmt) {
Ok(dt) => Ok(dt),
Err(err) => Err(FromSqlError::Other(Box::new(err))),
}
})
2016-02-22 20:36:49 +01:00
}
}
/// ISO 8601 combined date and time without timezone => "YYYY-MM-DD HH:MM:SS.SSS"
impl ToSql for NaiveDateTime {
unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
let date_str = self.format("%Y-%m-%dT%H:%M:%S%.f").to_string();
2016-02-22 20:36:49 +01:00
date_str.bind_parameter(stmt, col)
}
}
2016-05-16 10:02:07 -05:00
/// "YYYY-MM-DD HH:MM:SS"/"YYYY-MM-DD HH:MM:SS.SSS" => ISO 8601 combined date and time
/// without timezone. ("YYYY-MM-DDTHH:MM:SS"/"YYYY-MM-DDTHH:MM:SS.SSS" also supported)
2016-02-22 20:36:49 +01:00
impl FromSql for NaiveDateTime {
fn column_result(value: ValueRef) -> Result<Self, FromSqlError> {
value.as_str().and_then(|s| {
let fmt = if s.len() >= 11 && s.as_bytes()[10] == b'T' {
"%Y-%m-%dT%H:%M:%S%.f"
} else {
"%Y-%m-%d %H:%M:%S%.f"
};
match NaiveDateTime::parse_from_str(s, fmt) {
Ok(dt) => Ok(dt),
Err(err) => Err(FromSqlError::Other(Box::new(err))),
}
})
}
2016-02-22 20:36:49 +01:00
}
2016-05-16 09:08:31 -05:00
/// Date and time with time zone => UTC RFC3339 timestamp ("YYYY-MM-DDTHH:MM:SS.SSS+00:00").
impl<Tz: TimeZone> ToSql for DateTime<Tz> {
2016-02-22 20:36:49 +01:00
unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
2016-05-16 09:08:31 -05:00
let utc_dt = self.with_timezone(&UTC);
utc_dt.to_rfc3339().bind_parameter(stmt, col)
2016-02-22 20:36:49 +01:00
}
}
/// RFC3339 ("YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM") into DateTime<UTC>.
2016-02-22 20:36:49 +01:00
impl FromSql for DateTime<UTC> {
fn column_result(value: ValueRef) -> Result<Self, FromSqlError> {
{
// Try to parse value as rfc3339 first.
let s = try!(value.as_str());
// If timestamp looks space-separated, make a copy and replace it with 'T'.
let s = if s.len() >= 11 && s.as_bytes()[10] == b' ' {
let mut s = s.to_string();
unsafe {
let sbytes = s.as_mut_vec();
sbytes[10] = b'T';
}
Cow::Owned(s)
} else {
Cow::Borrowed(s)
};
match DateTime::parse_from_rfc3339(&s) {
Ok(dt) => return Ok(dt.with_timezone(&UTC)),
Err(_) => (),
}
2016-02-22 20:36:49 +01:00
}
// Couldn't parse as rfc3339 - fall back to NaiveDateTime.
NaiveDateTime::column_result(value).map(|dt| UTC.from_utc_datetime(&dt))
2016-02-22 20:36:49 +01:00
}
}
/// RFC3339 ("YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM") into DateTime<Local>.
2016-02-22 20:36:49 +01:00
impl FromSql for DateTime<Local> {
fn column_result(value: ValueRef) -> Result<Self, FromSqlError> {
let utc_dt = try!(DateTime::<UTC>::column_result(value));
Ok(utc_dt.with_timezone(&Local))
2016-02-22 20:36:49 +01:00
}
}
2016-02-23 18:18:56 +01:00
#[cfg(test)]
mod test {
use Connection;
2016-05-16 10:02:07 -05:00
use super::chrono::{DateTime, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, UTC,
Duration};
2016-02-23 18:18:56 +01:00
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT, b BLOB)").unwrap();
2016-02-23 18:18:56 +01:00
db
}
#[test]
fn test_naive_date() {
let db = checked_memory_handle();
2016-04-02 13:57:55 +02:00
let date = NaiveDate::from_ymd(2016, 2, 23);
db.execute("INSERT INTO foo (t) VALUES (?)", &[&date]).unwrap();
2016-02-23 18:18:56 +01:00
let s: String = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
2016-02-23 18:18:56 +01:00
assert_eq!("2016-02-23", s);
let t: NaiveDate = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
2016-04-02 13:57:55 +02:00
assert_eq!(date, t);
2016-02-23 18:18:56 +01:00
}
#[test]
fn test_naive_time() {
let db = checked_memory_handle();
2016-04-02 13:57:55 +02:00
let time = NaiveTime::from_hms(23, 56, 4);
db.execute("INSERT INTO foo (t) VALUES (?)", &[&time]).unwrap();
2016-02-23 18:18:56 +01:00
let s: String = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
assert_eq!("23:56:04", s);
let v: NaiveTime = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
2016-04-02 13:57:55 +02:00
assert_eq!(time, v);
2016-02-23 18:18:56 +01:00
}
#[test]
fn test_naive_date_time() {
let db = checked_memory_handle();
2016-04-02 13:57:55 +02:00
let date = NaiveDate::from_ymd(2016, 2, 23);
let time = NaiveTime::from_hms(23, 56, 4);
let dt = NaiveDateTime::new(date, time);
2016-02-23 18:18:56 +01:00
db.execute("INSERT INTO foo (t) VALUES (?)", &[&dt]).unwrap();
2016-02-23 18:18:56 +01:00
let s: String = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
assert_eq!("2016-02-23T23:56:04", s);
let v: NaiveDateTime = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
2016-02-23 18:18:56 +01:00
assert_eq!(dt, v);
db.execute("UPDATE foo set b = datetime(t)", &[]).unwrap(); // "YYYY-MM-DD HH:MM:SS"
2016-04-02 16:48:33 +02:00
let hms: NaiveDateTime = db.query_row("SELECT b FROM foo", &[], |r| r.get(0)).unwrap();
assert_eq!(dt, hms);
2016-02-23 18:18:56 +01:00
}
#[test]
fn test_date_time_utc() {
let db = checked_memory_handle();
2016-04-02 13:57:55 +02:00
let date = NaiveDate::from_ymd(2016, 2, 23);
let time = NaiveTime::from_hms_milli(23, 56, 4, 789);
2016-04-02 13:57:55 +02:00
let dt = NaiveDateTime::new(date, time);
2016-02-23 18:18:56 +01:00
let utc = UTC.from_utc_datetime(&dt);
db.execute("INSERT INTO foo (t) VALUES (?)", &[&utc]).unwrap();
2016-02-23 18:18:56 +01:00
let s: String = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
assert_eq!("2016-02-23T23:56:04.789+00:00", s);
let v1: DateTime<UTC> = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
assert_eq!(utc, v1);
2016-05-16 10:02:07 -05:00
let v2: DateTime<UTC> = db.query_row("SELECT '2016-02-23 23:56:04.789'", &[], |r| r.get(0))
.unwrap();
assert_eq!(utc, v2);
2016-05-16 10:02:07 -05:00
let v3: DateTime<UTC> = db.query_row("SELECT '2016-02-23 23:56:04'", &[], |r| r.get(0))
.unwrap();
assert_eq!(utc - Duration::milliseconds(789), v3);
2016-05-16 10:02:07 -05:00
let v4: DateTime<UTC> =
db.query_row("SELECT '2016-02-23 23:56:04.789+00:00'", &[], |r| r.get(0)).unwrap();
assert_eq!(utc, v4);
2016-02-23 18:18:56 +01:00
}
#[test]
fn test_date_time_local() {
let db = checked_memory_handle();
2016-04-02 13:57:55 +02:00
let date = NaiveDate::from_ymd(2016, 2, 23);
let time = NaiveTime::from_hms_milli(23, 56, 4, 789);
2016-04-02 13:57:55 +02:00
let dt = NaiveDateTime::new(date, time);
2016-02-23 18:18:56 +01:00
let local = Local.from_local_datetime(&dt).single().unwrap();
db.execute("INSERT INTO foo (t) VALUES (?)", &[&local]).unwrap();
2016-02-23 18:18:56 +01:00
2016-05-16 09:08:31 -05:00
// Stored string should be in UTC
let s: String = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
2016-05-16 09:08:31 -05:00
assert!(s.ends_with("+00:00"));
let v: DateTime<Local> = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
2016-02-23 18:18:56 +01:00
assert_eq!(local, v);
}
2016-02-23 18:18:56 +01:00
}