Merge remote-tracking branch 'jgallagher/master' into vtab

.travis.yml

@@ -13,5 +13,7 @@ script:
     - cargo test --features load_extension
     - cargo test --features trace
     - cargo test --features functions
-    - cargo test --features "functions vtab csvtab"
-    - cargo test --features "backup blob functions load_extension trace vtab csvtab"
+    - cargo test --features chrono
+    - cargo test --features serde_json
+    - cargo test --features "csvtab functions vtab"
+    - cargo test --features "backup blob chrono csvtab functions load_extension serde_json trace vtab"

Cargo.toml

@@ -26,6 +26,8 @@ time = "~0.1.0"
 bitflags = "~0.1"
 libc = "~0.2"
 clippy = {version = "~0.0.58", optional = true}
+chrono = { version = "~0.2", optional = true }
+serde_json = { version = "0.6", optional = true }
 
 [dev-dependencies]
 tempdir = "~0.3.4"

Changelog.md

@@ -1,5 +1,7 @@
 # Version UPCOMING (...)
 
+* Adds support for serializing types from the `serde_json` crate. Requires the `serde_json` feature.
+* Adds support for serializing types from the `chrono` crate. Requires the `chrono` feature.
 * Removes `load_extension` feature from `libsqlite3-sys`. `load_extension` is still available
   on rusqlite itself.
 * Fixes crash on nightly Rust when using the `trace` feature.

appveyor.yml

@@ -16,7 +16,7 @@ build: false
 
 test_script:
   - cargo test --lib --verbose
-  - cargo test --lib --features "backup blob functions load_extension trace vtab"
+  - cargo test --lib --features "backup blob chrono functions load_extension serde_json trace vtab"
 
 cache:
   - C:\Users\appveyor\.cargo

src/lib.rs

@@ -102,8 +102,7 @@ pub type Result<T> = result::Result<T, Error>;
 
 unsafe fn errmsg_to_string(errmsg: *const c_char) -> String {
     let c_slice = CStr::from_ptr(errmsg).to_bytes();
-    let utf8_str = str::from_utf8(c_slice);
-    utf8_str.unwrap_or("Invalid string encoding").to_owned()
+    String::from_utf8_lossy(c_slice).into_owned()
 }
 
 fn str_to_cstring(s: &str) -> Result<CString> {

src/trace.rs

@@ -27,9 +27,8 @@ pub unsafe fn config_log(callback: Option<fn(c_int, &str)>) -> Result<()> {
         let c_slice = unsafe { CStr::from_ptr(msg).to_bytes() };
         let callback: fn(c_int, &str) = unsafe { mem::transmute(p_arg) };
 
-        if let Ok(s) = str::from_utf8(c_slice) {
-            callback(err, s);
-        }
+        let s = String::from_utf8_lossy(c_slice);
+        callback(err, &s);
     }
 
     let rc = match callback {
@@ -70,9 +69,8 @@ impl Connection {
         unsafe extern "C" fn trace_callback(p_arg: *mut c_void, z_sql: *const c_char) {
             let trace_fn: fn(&str) = mem::transmute(p_arg);
             let c_slice = CStr::from_ptr(z_sql).to_bytes();
-            if let Ok(s) = str::from_utf8(c_slice) {
-                trace_fn(s);
-            }
+            let s = String::from_utf8_lossy(c_slice);
+            trace_fn(&s);
         }
 
         let c = self.db.borrow_mut();
@@ -96,13 +94,12 @@ impl Connection {
                                               nanoseconds: u64) {
             let profile_fn: fn(&str, Duration) = mem::transmute(p_arg);
             let c_slice = CStr::from_ptr(z_sql).to_bytes();
-            if let Ok(s) = str::from_utf8(c_slice) {
-                const NANOS_PER_SEC: u64 = 1_000_000_000;
+            let s = String::from_utf8_lossy(c_slice);
+            const NANOS_PER_SEC: u64 = 1_000_000_000;
 
-                let duration = Duration::new(nanoseconds / NANOS_PER_SEC,
-                                             (nanoseconds % NANOS_PER_SEC) as u32);
-                profile_fn(s, duration);
-            }
+            let duration = Duration::new(nanoseconds / NANOS_PER_SEC,
+                                         (nanoseconds % NANOS_PER_SEC) as u32);
+            profile_fn(&s, duration);
         }
 
         let c = self.db.borrow_mut();

src/types/chrono.rs

@@ -0,0 +1,239 @@
+//! Convert most of the [Time Strings](http://sqlite.org/lang_datefunc.html) to chrono types.
+extern crate chrono;
+
+use self::chrono::{NaiveDate, NaiveTime, NaiveDateTime, DateTime, TimeZone, UTC, Local};
+use libc::c_int;
+
+use {Error, Result};
+use types::{FromSql, ToSql};
+
+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.
+impl FromSql for NaiveDate {
+    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<NaiveDate> {
+        let s = try!(String::column_result(stmt, col));
+        match NaiveDate::parse_from_str(&s, "%Y-%m-%d") {
+            Ok(dt) => Ok(dt),
+            Err(err) => Err(Error::FromSqlConversionFailure(Box::new(err))),
+        }
+    }
+
+    unsafe fn column_has_valid_sqlite_type(stmt: *mut sqlite3_stmt, col: c_int) -> bool {
+        String::column_has_valid_sqlite_type(stmt, col)
+    }
+}
+
+/// 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();
+        date_str.bind_parameter(stmt, col)
+    }
+}
+
+/// "HH:MM"/"HH:MM:SS"/"HH:MM:SS.SSS" => ISO 8601 time without timezone.
+impl FromSql for NaiveTime {
+    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<NaiveTime> {
+        let s = try!(String::column_result(stmt, col));
+        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(Error::FromSqlConversionFailure(Box::new(err))),
+        }
+    }
+
+    unsafe fn column_has_valid_sqlite_type(stmt: *mut sqlite3_stmt, col: c_int) -> bool {
+        String::column_has_valid_sqlite_type(stmt, col)
+    }
+}
+
+/// 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();
+        date_str.bind_parameter(stmt, col)
+    }
+}
+
+/// "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)
+impl FromSql for NaiveDateTime {
+    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<NaiveDateTime> {
+        let s = try!(String::column_result(stmt, col));
+
+        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(Error::FromSqlConversionFailure(Box::new(err))),
+        }
+    }
+
+    unsafe fn column_has_valid_sqlite_type(stmt: *mut sqlite3_stmt, col: c_int) -> bool {
+        String::column_has_valid_sqlite_type(stmt, col)
+    }
+}
+
+/// Date and time with time zone => UTC RFC3339 timestamp ("YYYY-MM-DDTHH:MM:SS.SSS+00:00").
+impl<Tz: TimeZone> ToSql for DateTime<Tz> {
+    unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
+        let utc_dt = self.with_timezone(&UTC);
+        utc_dt.to_rfc3339().bind_parameter(stmt, col)
+    }
+}
+
+/// RFC3339 ("YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM") into DateTime<UTC>.
+impl FromSql for DateTime<UTC> {
+    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<DateTime<UTC>> {
+        let s = {
+            let mut s = try!(String::column_result(stmt, col));
+            if s.len() >= 11 {
+                let sbytes = s.as_mut_vec();
+                if sbytes[10] == b' ' {
+                    sbytes[10] = b'T';
+                }
+            }
+            s
+        };
+        match DateTime::parse_from_rfc3339(&s) {
+            Ok(dt) => Ok(dt.with_timezone(&UTC)),
+            Err(_) => NaiveDateTime::column_result(stmt, col).map(|dt| UTC.from_utc_datetime(&dt)),
+        }
+    }
+
+    unsafe fn column_has_valid_sqlite_type(stmt: *mut sqlite3_stmt, col: c_int) -> bool {
+        String::column_has_valid_sqlite_type(stmt, col)
+    }
+}
+
+/// RFC3339 ("YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM") into DateTime<Local>.
+impl FromSql for DateTime<Local> {
+    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<DateTime<Local>> {
+        let utc_dt = try!(DateTime::<UTC>::column_result(stmt, col));
+        Ok(utc_dt.with_timezone(&Local))
+    }
+
+    unsafe fn column_has_valid_sqlite_type(stmt: *mut sqlite3_stmt, col: c_int) -> bool {
+        DateTime::<UTC>::column_has_valid_sqlite_type(stmt, col)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use Connection;
+    use super::chrono::{DateTime, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, UTC,
+                        Duration};
+
+    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();
+        db
+    }
+
+    #[test]
+    fn test_naive_date() {
+        let db = checked_memory_handle();
+        let date = NaiveDate::from_ymd(2016, 2, 23);
+        db.execute("INSERT INTO foo (t) VALUES (?)", &[&date]).unwrap();
+
+        let s: String = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
+        assert_eq!("2016-02-23", s);
+        let t: NaiveDate = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
+        assert_eq!(date, t);
+    }
+
+    #[test]
+    fn test_naive_time() {
+        let db = checked_memory_handle();
+        let time = NaiveTime::from_hms(23, 56, 4);
+        db.execute("INSERT INTO foo (t) VALUES (?)", &[&time]).unwrap();
+
+        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();
+        assert_eq!(time, v);
+    }
+
+    #[test]
+    fn test_naive_date_time() {
+        let db = checked_memory_handle();
+        let date = NaiveDate::from_ymd(2016, 2, 23);
+        let time = NaiveTime::from_hms(23, 56, 4);
+        let dt = NaiveDateTime::new(date, time);
+
+        db.execute("INSERT INTO foo (t) VALUES (?)", &[&dt]).unwrap();
+
+        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();
+        assert_eq!(dt, v);
+
+        db.execute("UPDATE foo set b = datetime(t)", &[]).unwrap(); // "YYYY-MM-DD HH:MM:SS"
+        let hms: NaiveDateTime = db.query_row("SELECT b FROM foo", &[], |r| r.get(0)).unwrap();
+        assert_eq!(dt, hms);
+    }
+
+    #[test]
+    fn test_date_time_utc() {
+        let db = checked_memory_handle();
+        let date = NaiveDate::from_ymd(2016, 2, 23);
+        let time = NaiveTime::from_hms_milli(23, 56, 4, 789);
+        let dt = NaiveDateTime::new(date, time);
+        let utc = UTC.from_utc_datetime(&dt);
+
+        db.execute("INSERT INTO foo (t) VALUES (?)", &[&utc]).unwrap();
+
+        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);
+
+        let v2: DateTime<UTC> = db.query_row("SELECT '2016-02-23 23:56:04.789'", &[], |r| r.get(0))
+            .unwrap();
+        assert_eq!(utc, v2);
+
+        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);
+
+        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);
+    }
+
+    #[test]
+    fn test_date_time_local() {
+        let db = checked_memory_handle();
+        let date = NaiveDate::from_ymd(2016, 2, 23);
+        let time = NaiveTime::from_hms_milli(23, 56, 4, 789);
+        let dt = NaiveDateTime::new(date, time);
+        let local = Local.from_local_datetime(&dt).single().unwrap();
+
+        db.execute("INSERT INTO foo (t) VALUES (?)", &[&local]).unwrap();
+
+        // Stored string should be in UTC
+        let s: String = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
+        assert!(s.ends_with("+00:00"));
+
+        let v: DateTime<Local> = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
+        assert_eq!(local, v);
+    }
+}

src/types/mod.rs

@@ -52,8 +52,6 @@
 //! }
 //! ```
 
-extern crate time;
-
 use libc::{c_int, c_double, c_char};
 use std::ffi::CStr;
 use std::mem;
@@ -66,7 +64,11 @@ pub use ffi::sqlite3_column_type;
 
 pub use ffi::{SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB, SQLITE_NULL};
 
-const SQLITE_DATETIME_FMT: &'static str = "%Y-%m-%d %H:%M:%S";
+mod time;
+#[cfg(feature = "chrono")]
+mod chrono;
+#[cfg(feature = "serde_json")]
+mod serde_json;
 
 /// A trait for types that can be converted into SQLite values.
 pub trait ToSql {
@@ -154,13 +156,6 @@ impl ToSql for Vec<u8> {
     }
 }
 
-impl ToSql for time::Timespec {
-    unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
-        let time_str = time::at_utc(*self).strftime(SQLITE_DATETIME_FMT).unwrap().to_string();
-        time_str.bind_parameter(stmt, col)
-    }
-}
-
 impl<T: ToSql> ToSql for Option<T> {
     unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
         match *self {
@@ -263,22 +258,6 @@ impl FromSql for Vec<u8> {
     }
 }
 
-impl FromSql for time::Timespec {
-    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<time::Timespec> {
-        let col_str = FromSql::column_result(stmt, col);
-        col_str.and_then(|txt: String| {
-            match time::strptime(&txt, SQLITE_DATETIME_FMT) {
-                Ok(tm) => Ok(tm.to_timespec()),
-                Err(err) => Err(Error::FromSqlConversionFailure(Box::new(err))),
-            }
-        })
-    }
-
-    unsafe fn column_has_valid_sqlite_type(stmt: *mut sqlite3_stmt, col: c_int) -> bool {
-        String::column_has_valid_sqlite_type(stmt, col)
-    }
-}
-
 impl<T: FromSql> FromSql for Option<T> {
     unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<Option<T>> {
         if sqlite3_column_type(stmt, col) == ffi::SQLITE_NULL {
@@ -321,17 +300,14 @@ impl FromSql for Value {
             _ => Err(Error::InvalidColumnType),
         }
     }
-
-    unsafe fn column_has_valid_sqlite_type(_: *mut sqlite3_stmt, _: c_int) -> bool {
-        true
-    }
 }
 
 #[cfg(test)]
 #[cfg_attr(feature="clippy", allow(similar_names))]
 mod test {
+    extern crate time;
+
     use Connection;
-    use super::time;
     use Error;
     use libc::{c_int, c_double};
     use std::f64::EPSILON;
@@ -364,20 +340,6 @@ mod test {
         assert_eq!(from, s);
     }
 
-    #[test]
-    fn test_timespec() {
-        let db = checked_memory_handle();
-
-        let ts = time::Timespec {
-            sec: 10_000,
-            nsec: 0,
-        };
-        db.execute("INSERT INTO foo(t) VALUES (?)", &[&ts]).unwrap();
-
-        let from: time::Timespec = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
-        assert_eq!(from, ts);
-    }
-
     #[test]
     fn test_option() {
         let db = checked_memory_handle();
@@ -456,7 +418,6 @@ mod test {
         assert!(is_invalid_column_type(row.get_checked::<i32, c_double>(2).err().unwrap()));
         assert!(is_invalid_column_type(row.get_checked::<i32, String>(2).err().unwrap()));
         assert!(is_invalid_column_type(row.get_checked::<i32, Vec<u8>>(2).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32, time::Timespec>(2).err().unwrap()));
         assert!(is_invalid_column_type(row.get_checked::<i32, Option<c_double>>(2).err().unwrap()));
 
         // 3 is actually a float (c_double)
@@ -464,7 +425,6 @@ mod test {
         assert!(is_invalid_column_type(row.get_checked::<i32, i64>(3).err().unwrap()));
         assert!(is_invalid_column_type(row.get_checked::<i32, String>(3).err().unwrap()));
         assert!(is_invalid_column_type(row.get_checked::<i32, Vec<u8>>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32, time::Timespec>(3).err().unwrap()));
         assert!(is_invalid_column_type(row.get_checked::<i32, Option<c_int>>(3).err().unwrap()));
 
         // 4 is actually NULL

src/types/serde_json.rs

@@ -0,0 +1,66 @@
+//! `ToSql` and `FromSql` implementation for JSON `Value`.
+extern crate serde_json;
+
+use libc::c_int;
+use self::serde_json::Value;
+
+use {Error, Result};
+use types::{FromSql, ToSql};
+
+use ffi;
+use ffi::sqlite3_stmt;
+use ffi::sqlite3_column_type;
+
+/// Serialize JSON `Value` to text.
+impl ToSql for Value {
+    unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
+        let s = serde_json::to_string(self).unwrap();
+        s.bind_parameter(stmt, col)
+    }
+}
+
+/// Deserialize text/blob to JSON `Value`.
+impl FromSql for Value {
+    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<Value> {
+        let value_result = match sqlite3_column_type(stmt, col) {
+            ffi::SQLITE_TEXT => {
+                let s = try!(String::column_result(stmt, col));
+                serde_json::from_str(&s)
+            }
+            ffi::SQLITE_BLOB => {
+                let blob = try!(Vec::<u8>::column_result(stmt, col));
+                serde_json::from_slice(&blob)
+            }
+            _ => return Err(Error::InvalidColumnType),
+        };
+        value_result.map_err(|err| Error::FromSqlConversionFailure(Box::new(err)))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use Connection;
+    use super::serde_json;
+
+    fn checked_memory_handle() -> Connection {
+        let db = Connection::open_in_memory().unwrap();
+        db.execute_batch("CREATE TABLE foo (t TEXT, b BLOB)").unwrap();
+        db
+    }
+
+    #[test]
+    fn test_json_value() {
+        let db = checked_memory_handle();
+
+        let json = r#"{"foo": 13, "bar": "baz"}"#;
+        let data: serde_json::Value = serde_json::from_str(json).unwrap();
+        db.execute("INSERT INTO foo (t, b) VALUES (?, ?)",
+                     &[&data, &json.as_bytes()])
+            .unwrap();
+
+        let t: serde_json::Value = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
+        assert_eq!(data, t);
+        let b: serde_json::Value = db.query_row("SELECT b FROM foo", &[], |r| r.get(0)).unwrap();
+        assert_eq!(data, b);
+    }
+}

src/types/time.rs

@@ -0,0 +1,56 @@
+extern crate time;
+
+use libc::c_int;
+use {Error, Result};
+use types::{FromSql, ToSql};
+
+use ffi::sqlite3_stmt;
+
+const SQLITE_DATETIME_FMT: &'static str = "%Y-%m-%d %H:%M:%S";
+
+impl ToSql for time::Timespec {
+    unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
+        let time_str = time::at_utc(*self).strftime(SQLITE_DATETIME_FMT).unwrap().to_string();
+        time_str.bind_parameter(stmt, col)
+    }
+}
+
+impl FromSql for time::Timespec {
+    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<time::Timespec> {
+        let s = try!(String::column_result(stmt, col));
+        match time::strptime(&s, SQLITE_DATETIME_FMT) {
+            Ok(tm) => Ok(tm.to_timespec()),
+            Err(err) => Err(Error::FromSqlConversionFailure(Box::new(err))),
+        }
+    }
+
+    unsafe fn column_has_valid_sqlite_type(stmt: *mut sqlite3_stmt, col: c_int) -> bool {
+        String::column_has_valid_sqlite_type(stmt, col)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use Connection;
+    use super::time;
+
+    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_timespec() {
+        let db = checked_memory_handle();
+
+        let ts = time::Timespec {
+            sec: 10_000,
+            nsec: 0,
+        };
+        db.execute("INSERT INTO foo(t) VALUES (?)", &[&ts]).unwrap();
+
+        let from: time::Timespec = db.query_row("SELECT t FROM foo", &[], |r| r.get(0)).unwrap();
+        assert_eq!(from, ts);
+    }
+}