add support for DateTime, LocalDateTime & DateTime with zone id bolt

types

Author: yehohanan7

README.md

@@ -49,39 +49,6 @@ This driver is compatible with neo4j 4.x versions
 ```
 
 
-
----
-
-# Roadmap
-- [x] bolt protocol
-- [x] stream abstraction
-- [x] query.run() vs query.execute() abstraction
-- [x] respect "has_more" flag returned for PULL
-- [x] connection pooling
-- [x] explicit transactions
-- [x] use buffered TCP streams
-- [x] improve error messages & logging
-- [x] fetch rows in blocks
-- [x] configureable fetch size
-- [x] multi db support
-- [x] multi version support
-- [x] support data types
-	- [x] Float
-	- [x] Bytes
-- [ ] support structures
-	- [x] Relationship
-	- [x] Point2D
-	- [x] Point3D
-	- [x] UnboundedRelationship
-	- [x] Path
-	- [x] Duration
-	- [x] Date
-	- [x] Time
-	- [x] LocalTime
-	- [ ] DateTime
-	- [ ] DateTimeZoneId
-	- [ ] LocalDateTime
-
 ## License
 
 Neo4rs is licensed under either of the following, at your option:

lib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "neo4rs"
-version = "0.5.3"
+version = "0.5.4"
 authors = ["John Vincent <yehohanan7@gmail.com>"]
 edition = "2018"
 description = "neo4j driver in rust"

lib/src/convert.rs

@@ -69,6 +69,28 @@ impl TryFrom<BoltType> for chrono::NaiveDate {
     }
 }
 
+impl TryFrom<BoltType> for chrono::DateTime<chrono::FixedOffset> {
+    type Error = Error;
+
+    fn try_from(input: BoltType) -> Result<chrono::DateTime<chrono::FixedOffset>> {
+        match input {
+            BoltType::DateTime(d) => d.try_into(),
+            _ => Err(Error::ConverstionError),
+        }
+    }
+}
+
+impl TryFrom<BoltType> for chrono::NaiveDateTime {
+    type Error = Error;
+
+    fn try_from(input: BoltType) -> Result<chrono::NaiveDateTime> {
+        match input {
+            BoltType::LocalDateTime(d) => d.try_into(),
+            _ => Err(Error::ConverstionError),
+        }
+    }
+}
+
 impl TryFrom<BoltType> for (chrono::NaiveTime, Option<chrono::FixedOffset>) {
     type Error = Error;
 
@@ -88,6 +110,17 @@ impl TryFrom<BoltType> for (chrono::NaiveTime, Option<chrono::FixedOffset>) {
     }
 }
 
+impl TryFrom<BoltType> for (chrono::NaiveDateTime, String) {
+    type Error = Error;
+
+    fn try_from(input: BoltType) -> Result<(chrono::NaiveDateTime, String)> {
+        match input {
+            BoltType::DateTimeZoneId(date_time_zone_id) => date_time_zone_id.try_into(),
+            _ => Err(Error::ConverstionError),
+        }
+    }
+}
+
 impl TryFrom<BoltType> for Vec<u8> {
     type Error = Error;
 
@@ -202,12 +235,30 @@ impl Into<BoltType> for chrono::NaiveTime {
     }
 }
 
+impl Into<BoltType> for chrono::NaiveDateTime {
+    fn into(self) -> BoltType {
+        BoltType::LocalDateTime(self.into())
+    }
+}
+
+impl Into<BoltType> for chrono::DateTime<chrono::FixedOffset> {
+    fn into(self) -> BoltType {
+        BoltType::DateTime(self.into())
+    }
+}
+
 impl Into<BoltType> for (chrono::NaiveTime, chrono::FixedOffset) {
     fn into(self) -> BoltType {
         BoltType::Time(self.into())
     }
 }
 
+impl Into<BoltType> for (chrono::NaiveDateTime, &str) {
+    fn into(self) -> BoltType {
+        BoltType::DateTimeZoneId(self.into())
+    }
+}
+
 impl Into<BoltType> for Vec<u8> {
     fn into(self) -> BoltType {
         BoltType::Bytes(BoltBytes::new(self.into()))

lib/src/lib.rs

@@ -467,6 +467,10 @@
 //! ```
 //! ## Date
 //!
+//! See [NaiveDate][naive_date] for date abstraction, it captures the date without time component.
+//!
+//! [naive_date]: https://docs.rs/chrono/0.4.19/chrono/naive/struct.NaiveDate.html
+//!
 //! ```
 //! use neo4rs::*;
 //! use futures::stream::*;
@@ -493,14 +497,17 @@
 //!
 //! ## Time
 //!
-//! Neo4rs uses [chrono][chrono] crate for time abstractions.
+//! * [NaiveTime][naive_time] captures only the time of the day
+//! * `tuple`([NaiveTime][naive_time], `Option`<[FixedOffset][fixed_offset]>) captures the time of the day along with the
+//! offset
 //!
-//! [chrono]: https://crates.io/crates/chrono
+//! [naive_time]: https://docs.rs/chrono/0.4.19/chrono/naive/struct.NaiveTime.html
+//! [fixed_offset]: https://docs.rs/chrono/0.4.19/chrono/offset/struct.FixedOffset.html
 //!
 //!
 //! ### Time as param
 //!
-//! Pass a time (without offset) as a parameter to the query:
+//! Pass a time as a parameter to the query:
 //!
 //! ```
 //! use neo4rs::*;
@@ -583,6 +590,133 @@
 //!
 //! ```
 //!
+//!
+//! ## DateTime
+//!
+//!
+//! * [DateTime][date_time] captures the date and time with offset
+//! * [NaiveDateTime][naive_date_time] captures the date time without offset
+//! * `tuple`([NaiveDateTime][naive_date_time], String)  captures the date/time and the time zone id
+//!
+//! [date_time]: https://docs.rs/chrono/0.4.19/chrono/struct.DateTime.html
+//! [naive_date_time]: https://docs.rs/chrono/0.4.19/chrono/struct.NaiveDateTime.html
+//!
+//!
+//! ### DateTime as param
+//!
+//! Pass a DateTime as parameter to the query:
+//!
+//! ```
+//! use neo4rs::*;
+//! use futures::stream::*;
+//! use uuid::Uuid;
+//!
+//! #[tokio::main]
+//! async fn main() {
+//!    let uri = "127.0.0.1:7687";
+//!    let user = "neo4j";
+//!    let pass = "neo";
+//!    let graph = Graph::new(uri, user, pass).await.unwrap();
+//!
+//!    //send datetime as parameter in the query
+//!    let datetime = chrono::DateTime::parse_from_rfc2822("Tue, 01 Jul 2003 10:52:37 +0200").unwrap();
+//!
+//!    let mut result = graph
+//!        .execute(query("RETURN $d as output").param("d", datetime))
+//!        .await
+//!        .unwrap();
+//!    let row = result.next().await.unwrap().unwrap();
+//!    let t: chrono::DateTime<chrono::FixedOffset> = row.get("output").unwrap();
+//!    assert_eq!(t.to_string(), "2003-07-01 10:52:37 +02:00");
+//!    assert!(result.next().await.unwrap().is_none());
+//!
+//!    //send NaiveDateTime as parameter in the query
+//!    let localdatetime = chrono::NaiveDateTime::parse_from_str("2015-07-01 08:55:59.123", "%Y-%m-%d %H:%M:%S%.f").unwrap();
+//!
+//!    let mut result = graph
+//!        .execute(query("RETURN $d as output").param("d", localdatetime))
+//!        .await
+//!        .unwrap();
+//!    let row = result.next().await.unwrap().unwrap();
+//!    let t: chrono::NaiveDateTime = row.get("output").unwrap();
+//!    assert_eq!(t.to_string(), "2015-07-01 08:55:59.123");
+//!    assert!(result.next().await.unwrap().is_none());
+//!
+//!    //send NaiveDateTime with timezone id as parameter in the query
+//!    let datetime = chrono::NaiveDateTime::parse_from_str("2015-07-03 08:55:59.555", "%Y-%m-%d %H:%M:%S%.f").unwrap();
+//!    let timezone =  "Europe/Paris";
+//!
+//!    let mut result = graph
+//!        .execute(query("RETURN $d as output").param("d", (datetime, timezone)))
+//!        .await
+//!        .unwrap();
+//!    let row = result.next().await.unwrap().unwrap();
+//!    let (time, zone): (chrono::NaiveDateTime, String) = row.get("output").unwrap();
+//!    assert_eq!(time.to_string(), "2015-07-03 08:55:59.555");
+//!    assert_eq!(zone, "Europe/Paris");
+//!    assert!(result.next().await.unwrap().is_none());
+//!
+//! }
+//! ```
+//!
+//! ### Parsing DateTime from result
+//!
+//! ```
+//! use neo4rs::*;
+//! use futures::stream::*;
+//! use uuid::Uuid;
+//!
+//! #[tokio::main]
+//! async fn main() {
+//!    let uri = "127.0.0.1:7687";
+//!    let user = "neo4j";
+//!    let pass = "neo";
+//!    let graph = Graph::new(uri, user, pass).await.unwrap();
+//!
+//!    //Parse NaiveDateTime from result
+//!    let mut result = graph
+//!        .execute(query(
+//!            "WITH localdatetime('2015-06-24T12:50:35.556') AS t RETURN t",
+//!        ))
+//!        .await
+//!        .unwrap();
+//!    let row = result.next().await.unwrap().unwrap();
+//!    let t: chrono::NaiveDateTime = row.get("t").unwrap();
+//!    assert_eq!(t.to_string(), "2015-06-24 12:50:35.556");
+//!    assert!(result.next().await.unwrap().is_none());
+//!
+//!    //Parse DateTime from result
+//!    let mut result = graph
+//!        .execute(query(
+//!            "WITH datetime('2015-06-24T12:50:35.777+0100') AS t RETURN t",
+//!        ))
+//!        .await
+//!        .unwrap();
+//!    let row = result.next().await.unwrap().unwrap();
+//!    let t: chrono::DateTime<chrono::FixedOffset> = row.get("t").unwrap();
+//!    assert_eq!(t.to_string(), "2015-06-24 12:50:35.777 +01:00");
+//!    assert!(result.next().await.unwrap().is_none());
+//!
+//!
+//!    //Parse NaiveDateTime with zone id from result
+//!    let mut result = graph
+//!        .execute(query(
+//!            "WITH datetime({ year:1984, month:11, day:11, hour:12, minute:31, second:14, nanosecond: 645876123, timezone:'Europe/Stockholm' }) AS d return d",
+//!        ))
+//!        .await
+//!        .unwrap();
+//!    let row = result.next().await.unwrap().unwrap();
+//!    let (datetime, zone_id): (chrono::NaiveDateTime, String) = row.get("d").unwrap();
+//!    assert_eq!(datetime.to_string(), "1984-11-11 12:31:14.645876123");
+//!    assert_eq!(zone_id, "Europe/Stockholm");
+//!    assert!(result.next().await.unwrap().is_none());
+//!
+//! }
+//!
+//! ```
+//!
+//!
+//!
 //! ## Path
 //!
 //! ```

lib/src/types.rs

@@ -1,6 +1,7 @@
 pub mod binary;
 pub mod boolean;
 pub mod date;
+pub mod date_time;
 pub mod duration;
 pub mod float;
 pub mod integer;
@@ -16,6 +17,7 @@ pub mod time;
 pub use binary::BoltBytes;
 pub use boolean::BoltBoolean;
 pub use date::BoltDate;
+pub use date_time::{BoltDateTime, BoltDateTimeZoneId, BoltLocalDateTime};
 pub use duration::BoltDuration;
 pub use float::BoltFloat;
 pub use integer::BoltInteger;
@@ -57,6 +59,9 @@ pub enum BoltType {
     Date(BoltDate),
     Time(BoltTime),
     LocalTime(BoltLocalTime),
+    DateTime(BoltDateTime),
+    LocalDateTime(BoltLocalDateTime),
+    DateTimeZoneId(BoltDateTimeZoneId),
 }
 
 impl Display for BoltType {
@@ -81,6 +86,9 @@ impl Hash for BoltType {
             BoltType::Date(t) => t.hash(state),
             BoltType::Time(t) => t.hash(state),
             BoltType::LocalTime(t) => t.hash(state),
+            BoltType::DateTime(t) => t.hash(state),
+            BoltType::LocalDateTime(t) => t.hash(state),
+            BoltType::DateTimeZoneId(t) => t.hash(state),
             //The below types cannot be hashed
             BoltType::Path(_) => panic!("path not hashed"),
             BoltType::Bytes(_) => panic!("bytes not hashed"),
@@ -116,6 +124,9 @@ impl BoltType {
             BoltType::Date(t) => t.to_bytes(version),
             BoltType::Time(t) => t.to_bytes(version),
             BoltType::LocalTime(t) => t.to_bytes(version),
+            BoltType::DateTime(t) => t.to_bytes(version),
+            BoltType::LocalDateTime(t) => t.to_bytes(version),
+            BoltType::DateTimeZoneId(t) => t.to_bytes(version),
         }
     }
 
@@ -166,6 +177,15 @@ impl BoltType {
             input if BoltLocalTime::can_parse(version, input.clone()) => {
                 BoltType::LocalTime(BoltLocalTime::parse(version, input)?)
             }
+            input if BoltDateTime::can_parse(version, input.clone()) => {
+                BoltType::DateTime(BoltDateTime::parse(version, input)?)
+            }
+            input if BoltLocalDateTime::can_parse(version, input.clone()) => {
+                BoltType::LocalDateTime(BoltLocalDateTime::parse(version, input)?)
+            }
+            input if BoltDateTimeZoneId::can_parse(version, input.clone()) => {
+                BoltType::DateTimeZoneId(BoltDateTimeZoneId::parse(version, input)?)
+            }
             input if BoltUnboundedRelation::can_parse(version, input.clone()) => {
                 BoltType::UnboundedRelation(BoltUnboundedRelation::parse(version, input)?)
             }