feat: flag for time/chrono crate support

Introduces a new --temporal option to choose temporal type mapping:
- numeric (default): primitive types for backward compatibility
- time: uses time crate (time::Date, time::OffsetDateTime, time::Duration)
- chrono: uses chrono crate (chrono::NaiveDate, chrono::DateTime, etc.)
- Adds support for ClickHouse Time and Time64(precision) types.

Updated all snapshots.

Author: JoeTurki

CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 
 ## [Unreleased] - ReleaseDate
+### Added
+- Support for ClickHouse `Time` and `Time64(precision)` types.
+- New `--temporal` option to choose temporal type mapping mode: `numeric` (default), `time`, or `chrono`.
+  - **numeric** mode (default): maintains backward compatibility, uses primitive Rust types (u16, i32, u32, i64).
+  - **time** mode: uses `time` crate types (`time::Date`, `time::OffsetDateTime`, `time::Duration`).
+  - **chrono** mode: uses `chrono` crate types (`chrono::NaiveDate`, `chrono::DateTime<Utc>`, `chrono::Duration`).
+- Comprehensive serde support for temporal types in all modes with appropriate precision handling.
 
 ## [0.1.8] - 2024-09-27
 ### Added

Cargo.toml

@@ -20,7 +20,7 @@ native-tls = ["clickhouse/native-tls"]
 
 [dependencies]
 anyhow = "1.0.40"
-clickhouse =  "0.13.0"
+clickhouse =  "0.14.0"
 heck = "0.5.0"
 serde = { version = "1.0.126", features = ["derive"] }
 structopt = "0.3.21"
@@ -32,4 +32,6 @@ serde_repr = "0.1.7"
 serde_bytes = "0.11.5"
 trybuild = "1.0.42"
 uuid = "1.2.1"
-clickhouse = { version = "0.13.0", features = ["uuid"] }
+clickhouse = { version = "0.14.0", features = ["uuid", "time", "chrono"] }
+time = { version = "0.3.44", features = ["serde"] }
+chrono = { version = "0.4.42", features = ["serde"] }

README.md

@@ -8,7 +8,7 @@ An auxiliary utility for generating Rust structures from ClickHouse DB schemas f
 cargo install ch2rs
 ```
 
-The crate enables `rustls-tls` [client](https://github.com/ClickHouse/clickhouse-rs/blob/main/Cargo.toml) feature by default, which allows to work with HTTPS URLs. 
+The crate enables `rustls-tls` [client](https://github.com/ClickHouse/clickhouse-rs/blob/main/Cargo.toml) feature by default, which allows to work with HTTPS URLs.
 If `rustls-tls` does not work in your use case, you can install the crate with `native-tls` instead:
 
 ```sh
@@ -43,12 +43,36 @@ OPTIONS:
         --derive <trait>...    Add `#[derive(<trait>)]` to the generated types
     -T <types>...              Override the type, e.g. 'Decimal(18, 9)=fixnum::FixedPoint<i64, typenum::U9>'
     -U <url>                   ClickHouse server's URL [default: localhost:8123]
+    --temporal <mode>          Temporal mapping: numeric|time|chrono [default: numeric]
     -u <user>
 
 ARGS:
     <table>    The table's name
 ```
 
+### Temporal modes
+
+- **numeric** (default): uses primitive Rust types:
+  - Date → `u16`, Date32 → `i32`
+  - DateTime → `u32`, DateTime64(_) → `i64`
+  - Time → `i32`, Time64(_) → `i64`
+
+- **time**: uses the `time` crate types
+  - Date/Date32: `time::Date`
+  - DateTime/DateTime64: `time::OffsetDateTime`
+  - Time/Time64: `time::Duration`
+  - Requires in your project: `time` dependency and `clickhouse` feature `time`
+    - `clickhouse = { version = "…", features = ["time"] }`
+
+- **chrono**: uses the `chrono` crate types
+  - Date/Date32: `chrono::NaiveDate`
+  - DateTime/DateTime64: `chrono::DateTime<chrono::Utc>`
+  - Time/Time64: `chrono::Duration`
+  - Requires in your project: `chrono` dependency and `clickhouse` feature `chrono`
+    - `clickhouse = { version = "…", features = ["chrono"] }`
+
+Select mode via `--temporal {numeric|time|chrono}`.
+
 ## Examples
 
 See [snapshots](tests/snapshots).

src/codegen.rs

@@ -4,7 +4,7 @@ use anyhow::{bail, Context, Result};
 use heck::{ToSnakeCase, ToUpperCamelCase};
 
 use crate::{
-    options::Options,
+    options::{Options, Temporal},
     schema::{Column, SqlType, Table},
 };
 
@@ -82,18 +82,46 @@ fn make_attribute(column: &Column, options: &Options) -> Option<String> {
         return None;
     }
 
-    let attr = match column.type_ {
-        SqlType::UUID => r#"    #[serde(with = "::clickhouse::serde::uuid")]"#,
-        SqlType::IPv4 => r#"    #[serde(with = "::clickhouse::serde::ipv4")]"#,
-        SqlType::Nullable(ref inner) => match inner.as_ref() {
-            SqlType::UUID => r#"    #[serde(with = "::clickhouse::serde::uuid::option")]"#,
-            SqlType::IPv4 => r#"    #[serde(with = "::clickhouse::serde::ipv4::option")]"#,
-            _ => return None,
-        },
-        _ => return None,
+    let (inner, is_option) = match &column.type_ {
+        SqlType::Nullable(inner) => (inner.as_ref(), true),
+        _ => (&column.type_, false),
     };
 
-    Some(attr.into())
+    let base = match inner {
+        SqlType::UUID => Some("::clickhouse::serde::uuid".into()),
+        SqlType::IPv4 => Some("::clickhouse::serde::ipv4".into()),
+        SqlType::Date => temporal_path(options.temporal, "date", None),
+        SqlType::Date32 => temporal_path(options.temporal, "date32", None),
+        SqlType::DateTime(_) => temporal_path(options.temporal, "datetime", None),
+        SqlType::DateTime64(prec, _) => temporal_path(options.temporal, "datetime64", Some(prec)),
+        SqlType::Time => temporal_path(options.temporal, "time", None),
+        SqlType::Time64(prec) => temporal_path(options.temporal, "time64", Some(prec)),
+        _ => None,
+    }?;
+
+    Some(format!(
+        "    #[serde(with = \"{}{}\")]",
+        base,
+        if is_option { "::option" } else { "" }
+    ))
+}
+
+fn temporal_path(temporal_mode: Temporal, ty: &str, prec: Option<&u32>) -> Option<String> {
+    let temporal_base = match temporal_mode {
+        Temporal::Time => Some("::clickhouse::serde::time::"),
+        Temporal::Chrono => Some("::clickhouse::serde::chrono::"),
+        Temporal::Numeric => None,
+    }?;
+    let prec = match prec {
+        None => Some(""),
+        Some(&0) => Some("::secs"),
+        Some(&3) => Some("::millis"),
+        Some(&6) => Some("::micros"),
+        Some(&9) => Some("::nanos"),
+        Some(_) => None,
+    }?;
+
+    Some(format!("{}{}{}", temporal_base, ty, prec))
 }
 
 fn make_type(column: &Column, options: &Options) -> Result<String> {
@@ -105,6 +133,20 @@ fn do_make_type(name: &str, sql_type: &SqlType, options: &Options) -> Result<Str
         return Ok(type_.into());
     }
 
+    // validate precision for chrono and time modes.
+    if matches!(options.temporal, Temporal::Time | Temporal::Chrono) {
+        if let SqlType::DateTime64(p, _) | SqlType::Time64(p) = sql_type {
+            if !matches!(p, 0 | 3 | 6 | 9) {
+                bail!(
+                    "Unsupported precision {} for {:?} in {:?} mode; supported: 0, 3, 6, 9",
+                    p,
+                    sql_type,
+                    options.temporal
+                );
+            }
+        }
+    }
+
     Ok(match sql_type {
         SqlType::UInt8 => "u8".into(),
         SqlType::UInt16 => "u16".into(),
@@ -122,9 +164,38 @@ fn do_make_type(name: &str, sql_type: &SqlType, options: &Options) -> Result<Str
         // SqlType::FixedString(size) => todo!(),
         SqlType::Float32 => "f32".into(),
         SqlType::Float64 => "f64".into(),
-        // SqlType::Date => todo!(),
-        // SqlType::DateTime(_) => todo!(),
-        // SqlType::DateTime64(_, _) => todo!(),
+        SqlType::Date
+        | SqlType::Date32
+        | SqlType::DateTime(_)
+        | SqlType::DateTime64(_, _)
+        | SqlType::Time
+        | SqlType::Time64(_) => match options.temporal {
+            Temporal::Numeric => match sql_type {
+                SqlType::Date => "u16".into(),
+                SqlType::Date32 => "i32".into(),
+                SqlType::DateTime(_) => "u32".into(),
+                SqlType::DateTime64(_, _) => "i64".into(),
+                SqlType::Time => "i32".into(),
+                SqlType::Time64(_) => "i64".into(),
+                _ => unreachable!(),
+            },
+            Temporal::Time => match sql_type {
+                SqlType::Date | SqlType::Date32 => "::time::Date".into(),
+                SqlType::DateTime(_) => "::time::OffsetDateTime".into(),
+                SqlType::DateTime64(..) => "::time::OffsetDateTime".into(),
+                SqlType::Time => "::time::Duration".into(),
+                SqlType::Time64(_) => "::time::Duration".into(),
+                _ => unreachable!(),
+            },
+            Temporal::Chrono => match sql_type {
+                SqlType::Date | SqlType::Date32 => "::chrono::NaiveDate".into(),
+                SqlType::DateTime(_) => "::chrono::DateTime<::chrono::Utc>".into(),
+                SqlType::DateTime64(..) => "::chrono::DateTime<::chrono::Utc>".into(),
+                SqlType::Time => "::chrono::Duration".into(),
+                SqlType::Time64(_) => "::chrono::Duration".into(),
+                _ => unreachable!(),
+            },
+        },
         SqlType::IPv4 => "::std::net::Ipv4Addr".into(),
         SqlType::IPv6 => "::std::net::Ipv6Addr".into(),
         SqlType::UUID => "::uuid::Uuid".into(),

src/miner.rs

@@ -112,7 +112,9 @@ pub fn parse_type(raw: &str) -> Result<SqlType> {
         "Float32" => SqlType::Float32,
         "Float64" => SqlType::Float64,
         "Date" => SqlType::Date,
+        "Date32" => SqlType::Date32,
         "DateTime" => SqlType::DateTime(None),
+        "Time" => SqlType::Time,
         "IPv4" => SqlType::IPv4,
         "IPv6" => SqlType::IPv6,
         "UUID" => SqlType::UUID,
@@ -134,6 +136,11 @@ pub fn parse_type(raw: &str) -> Result<SqlType> {
                 let prec = prec.trim().parse().context("invalid precision")?;
                 SqlType::DateTime64(prec, tz.map(str::trim).map(Into::into))
             }
+            // Time64(prec)
+            else if let Some(inner) = extract_inner(raw, "Time64") {
+                let prec = inner.trim().parse().context("invalid precision")?;
+                SqlType::Time64(prec)
+            }
             // Enum8('K' = v, 'K2' = v2)
             else if let Some(inner) = extract_inner(raw, "Enum8") {
                 SqlType::Enum8(parse_kv_list(inner).context("invalid enum")?)

src/options.rs

@@ -46,6 +46,10 @@ pub struct Options {
     /// Add `#[derive(<trait>)]` to the generated types.
     #[structopt(long = "derive", number_of_values = 1, name = "trait")]
     pub derives: Vec<String>,
+
+    /// Temporal mapping mode
+    #[structopt(long = "temporal", default_value = "numeric", possible_values=&["numeric", "time", "chrono"])]
+    pub temporal: Temporal,
 }
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
@@ -76,6 +80,35 @@ fn parse_override(s: &str) -> Result<Override> {
     })
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Temporal {
+    Numeric,
+    Time,
+    Chrono,
+}
+
+impl std::str::FromStr for Temporal {
+    type Err = String;
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s {
+            "numeric" => Ok(Temporal::Numeric),
+            "time" => Ok(Temporal::Time),
+            "chrono" => Ok(Temporal::Chrono),
+            _ => Err("invalid temporal".into()),
+        }
+    }
+}
+
+impl std::fmt::Display for Temporal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Temporal::Numeric => f.write_str("numeric"),
+            Temporal::Time => f.write_str("time"),
+            Temporal::Chrono => f.write_str("chrono"),
+        }
+    }
+}
+
 impl Options {
     pub fn format(&self) -> String {
         let mut s = String::new();
@@ -140,6 +173,10 @@ impl Options {
             let _ = writeln!(&mut s, "    -I '{}' \\", i);
         }
 
+        if self.temporal != Temporal::Numeric {
+            let _ = write!(&mut s, " --temporal {}", self.temporal);
+        }
+
         s.trim_end_matches(|c| ['\\', ' ', '\n'].contains(&c))
             .into()
     }

src/schema.rs

@@ -31,8 +31,11 @@ pub enum SqlType {
     Float32,
     Float64,
     Date,
+    Date32,
     DateTime(Option<String>),
     DateTime64(u32, Option<String>),
+    Time,
+    Time64(u32),
     IPv4,
     IPv6,
     UUID,