diff --git a/src/cache.rs b/src/cache.rs
index bfafbac..d5bb5b4 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -46,6 +46,7 @@ impl Connection {
         self.cache.set_capacity(capacity)
     }
 
+    /// Remove/finalize all prepared statements currently in the cache.
     pub fn flush_prepared_statement_cache(&self) {
         self.cache.flush()
     }
@@ -124,7 +125,7 @@ impl StatementCache {
                   sql: &str)
                   -> Result<CachedStatement<'conn>> {
         let mut cache = self.0.borrow_mut();
-        let stmt = match cache.remove(sql) {
+        let stmt = match cache.remove(sql.trim()) {
             Some(raw_stmt) => Ok(Statement::new(conn, raw_stmt)),
             None => conn.prepare(sql),
         };
@@ -135,7 +136,7 @@ impl StatementCache {
     fn cache_stmt(&self, stmt: RawStatement) {
         let mut cache = self.0.borrow_mut();
         stmt.clear_bindings();
-        let sql = String::from_utf8_lossy(stmt.sql().to_bytes()).to_string();
+        let sql = String::from_utf8_lossy(stmt.sql().to_bytes()).trim().to_string();
         cache.insert(sql, stmt);
     }
 
@@ -285,4 +286,27 @@ mod test {
 
         conn.close().expect("connection not closed");
     }
+
+    #[test]
+    fn test_cache_key() {
+        let db = Connection::open_in_memory().unwrap();
+        let cache = &db.cache;
+        assert_eq!(0, cache.len());
+
+        //let sql = " PRAGMA schema_version; -- comment";
+        let sql = "PRAGMA schema_version; ";
+        {
+            let mut stmt = db.prepare_cached(sql).unwrap();
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row(&[], |r| r.get::<i32, i64>(0)).unwrap());
+        }
+        assert_eq!(1, cache.len());
+
+        {
+            let mut stmt = db.prepare_cached(sql).unwrap();
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row(&[], |r| r.get::<i32, i64>(0)).unwrap());
+        }
+        assert_eq!(1, cache.len());
+    }
 }
diff --git a/src/types/mod.rs b/src/types/mod.rs
index c998d89..74757cb 100644
--- a/src/types/mod.rs
+++ b/src/types/mod.rs
@@ -10,12 +10,13 @@
 //! * Strings (`String` and `&str`)
 //! * Blobs (`Vec<u8>` and `&[u8]`)
 //!
-//! Additionally, because it is such a common data type, implementations are provided for
-//! `time::Timespec` that use a string for storage (using the same format string,
-//! `"%Y-%m-%d %H:%M:%S"`, as SQLite's builtin
-//! [datetime](https://www.sqlite.org/lang_datefunc.html) function.  Note that this storage
-//! truncates timespecs to the nearest second. If you want different storage for timespecs, you can
-//! use a newtype. For example, to store timespecs as `f64`s:
+//! Additionally, because it is such a common data type, implementations are
+//! provided for `time::Timespec` that use the RFC 3339 date/time format,
+//! `"%Y-%m-%dT%H:%M:%S.%fZ"`, to store time values as strings.  These values
+//! can be parsed by SQLite's builtin
+//! [datetime](https://www.sqlite.org/lang_datefunc.html) functions.  If you
+//! want different storage for timespecs, you can use a newtype. For example, to
+//! store timespecs as `f64`s:
 //!
 //! ```rust
 //! extern crate rusqlite;
diff --git a/src/types/time.rs b/src/types/time.rs
index f0dd46c..458435c 100644
--- a/src/types/time.rs
+++ b/src/types/time.rs
@@ -3,7 +3,8 @@ extern crate time;
 use Result;
 use types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
 
-const SQLITE_DATETIME_FMT: &str = "%Y-%m-%d %H:%M:%S:%f %Z";
+const SQLITE_DATETIME_FMT: &str = "%Y-%m-%dT%H:%M:%S.%fZ";
+const SQLITE_DATETIME_FMT_LEGACY: &str = "%Y-%m-%d %H:%M:%S:%f %Z";
 
 impl ToSql for time::Timespec {
     fn to_sql(&self) -> Result<ToSqlOutput> {
@@ -19,10 +20,12 @@ impl FromSql for time::Timespec {
     fn column_result(value: ValueRef) -> FromSqlResult<Self> {
         value
             .as_str()
-            .and_then(|s| match time::strptime(s, SQLITE_DATETIME_FMT) {
-                          Ok(tm) => Ok(tm.to_timespec()),
-                          Err(err) => Err(FromSqlError::Other(Box::new(err))),
-                      })
+            .and_then(|s| {
+                time::strptime(s, SQLITE_DATETIME_FMT)
+                    .or_else(|err| {
+                        time::strptime(s, SQLITE_DATETIME_FMT_LEGACY)
+                            .or(Err(FromSqlError::Other(Box::new(err))))})})
+            .map(|tm| tm.to_timespec())
     }
 }