Add support for the Duration CQL data type

Example of the Duration CQL data type usage in a rune script:

  let d1 = "1y3mo2w6d13h14m22s33ms44us55ns";
  let d2 = "55mo345d11ns";
  let d3 = "1m5s3ms";
  let d4 = "5s";

Author: vponomaryov

src/scripting/bind.rs

@@ -3,19 +3,18 @@
 use crate::scripting::cass_error::{CassError, CassErrorKind};
 use crate::scripting::cql_types::Uuid;
 use chrono::{NaiveDate, NaiveTime};
+use regex::Regex;
 use rune::{Any, ToValue, Value};
 use scylla::_macro_internal::ColumnType;
 use scylla::frame::response::result::{CollectionType, ColumnSpec, NativeType};
 use scylla::response::query_result::ColumnSpecs;
-use scylla::value::{CqlDate, CqlTime, CqlTimeuuid, CqlValue, CqlVarint};
+use scylla::value::{CqlDate, CqlDuration, CqlTime, CqlTimeuuid, CqlValue, CqlVarint};
 use std::net::IpAddr;
 use std::str::FromStr;
 
 use itertools::*;
 
 fn to_scylla_value(v: &Value, typ: &ColumnType) -> Result<CqlValue, CassError> {
-    // TODO: add support for the following CQL data types:
-    //       'duration'
     match (v, typ) {
         (Value::Bool(v), ColumnType::Native(NativeType::Boolean)) => Ok(CqlValue::Boolean(*v)),
 
@@ -105,6 +104,74 @@ fn to_scylla_value(v: &Value, typ: &ColumnType) -> Result<CqlValue, CassError> {
             let cql_time = CqlTime::try_from(naive_time)?;
             Ok(CqlValue::Time(cql_time))
         }
+        (Value::String(s), ColumnType::Native(NativeType::Duration)) => {
+            // TODO: add support for the following 'ISO 8601' format variants:
+            // - ISO 8601 format: P[n]Y[n]M[n]DT[n]H[n]M[n]S or P[n]W
+            // - ISO 8601 alternative format: P[YYYY]-[MM]-[DD]T[hh]:[mm]:[ss]
+            // See: https://opensource.docs.scylladb.com/stable/cql/types.html#working-with-durations
+            let duration_str = s.borrow_ref().unwrap();
+            if duration_str.is_empty() {
+                return Err(CassError(CassErrorKind::QueryParamConversion(
+                    format!("{:?}", v),
+                    "NativeType::Duration".to_string(),
+                    Some("Duration cannot be empty".to_string()),
+                )));
+            }
+            // NOTE: we parse the duration explicitly because of the 'CqlDuration' type specifics.
+            // It stores only months, days and nanoseconds.
+            // So, we do not translate days to months and hours to days because those are ambiguous
+            let re = Regex::new(concat!(
+                r"(?P<years>\d+)y|",
+                r"(?P<months>\d+)mo|",
+                r"(?P<weeks>\d+)w|",
+                r"(?P<days>\d+)d|",
+                r"(?P<hours>\d+)h|",
+                r"(?P<seconds>\d+)s|",
+                r"(?P<millis>\d+)ms|",
+                r"(?P<micros>\d+)us|",
+                r"(?P<nanoseconds>\d+)ns|",
+                r"(?P<minutes>\d+)m|", // must be after 'mo' and 'ms' matchers
+                r"(?P<invalid>.+)",    // must be last
+            ))
+            .unwrap();
+            let (mut months, mut days, mut nanoseconds) = (0, 0, 0);
+            for cap in re.captures_iter(&duration_str) {
+                if let Some(m) = cap.name("years") {
+                    months += m.as_str().parse::<i32>().unwrap() * 12;
+                } else if let Some(m) = cap.name("months") {
+                    months += m.as_str().parse::<i32>().unwrap();
+                } else if let Some(m) = cap.name("weeks") {
+                    days += m.as_str().parse::<i32>().unwrap() * 7;
+                } else if let Some(m) = cap.name("days") {
+                    days += m.as_str().parse::<i32>().unwrap();
+                } else if let Some(m) = cap.name("hours") {
+                    nanoseconds += m.as_str().parse::<i64>().unwrap() * 3_600_000_000_000;
+                } else if let Some(m) = cap.name("minutes") {
+                    nanoseconds += m.as_str().parse::<i64>().unwrap() * 60_000_000_000;
+                } else if let Some(m) = cap.name("seconds") {
+                    nanoseconds += m.as_str().parse::<i64>().unwrap() * 1_000_000_000;
+                } else if let Some(m) = cap.name("millis") {
+                    nanoseconds += m.as_str().parse::<i64>().unwrap() * 1_000_000;
+                } else if let Some(m) = cap.name("micros") {
+                    nanoseconds += m.as_str().parse::<i64>().unwrap() * 1_000;
+                } else if let Some(m) = cap.name("nanoseconds") {
+                    nanoseconds += m.as_str().parse::<i64>().unwrap();
+                } else if cap.name("invalid").is_some() {
+                    return Err(CassError(CassErrorKind::QueryParamConversion(
+                        format!("{:?}", v),
+                        "NativeType::Duration".to_string(),
+                        Some("Got invalid duration value".to_string()),
+                    )));
+                }
+            }
+            let cql_duration = CqlDuration {
+                months,
+                days,
+                nanoseconds,
+            };
+            Ok(CqlValue::Duration(cql_duration))
+        }
+
         (Value::String(s), ColumnType::Native(NativeType::Varint)) => {
             let varint_str = s.borrow_ref().unwrap();
             if !varint_str.chars().all(|c| c.is_ascii_digit()) {