refactor: replace chrono::Tz with jiff::tz::Timezone (#719)

youngsofun · web-flow · commit 9f86e55de3fe · 2025-11-20T02:10:08.000+08:00
diff --git a/core/Cargo.toml b/core/Cargo.toml
@@ -26,8 +26,8 @@ arrow-ipc = { workspace = true }
 arrow-schema = { workspace = true }
 bytes = "1.10.1"
 base64 = "0.22.1"
-chrono-tz = { workspace = true }
 cookie = "0.18.1"
+jiff = { version = "0.2.10", features = ["tzdb-bundle-always"] }
 log = { version = "0.4", features = ["kv"] }
 once_cell = "1.21"
 parking_lot = "0.12.3"
diff --git a/core/src/settings.rs b/core/src/settings.rs
@@ -14,15 +14,24 @@
 
 use crate::error::Result;
 use crate::Error;
-use chrono_tz::Tz;
+use jiff::tz::TimeZone;
 use serde::Deserialize;
 use std::collections::BTreeMap;
 use std::str::FromStr;
 
-#[derive(Debug, Clone, Default, Copy)]
+#[derive(Debug, Clone)]
 pub struct ResultFormatSettings {
     pub geometry_output_format: GeometryDataType,
-    pub timezone: Tz,
+    pub timezone: TimeZone,
+}
+
+impl Default for ResultFormatSettings {
+    fn default() -> Self {
+        Self {
+            geometry_output_format: GeometryDataType::default(),
+            timezone: TimeZone::UTC,
+        }
+    }
 }
 
 impl ResultFormatSettings {
@@ -31,8 +40,8 @@ impl ResultFormatSettings {
             None => Ok(Default::default()),
             Some(settings) => {
                 let timezone = match settings.get("timezone") {
-                    None => Tz::default(),
-                    Some(t) => Tz::from_str(t).map_err(|e| Error::Decode(e.to_string()))?,
+                    None => TimeZone::UTC,
+                    Some(t) => TimeZone::get(t).map_err(|e| Error::Decode(e.to_string()))?,
                 };
 
                 let geometry_output_format = match settings.get("geometry_output_format") {
diff --git a/driver/Cargo.toml b/driver/Cargo.toml
@@ -38,6 +38,7 @@ tokio-stream = { workspace = true }
 tonic = { workspace = true, optional = true }
 
 async-trait = "0.1"
+jiff = { version = "0.2.10", features = ["tzdb-bundle-always"] }
 csv = "1.3"
 databend-common-ast = "0.2.3"
 derive-visitor = { version = "0.4.0", features = ["std-types-drive"] }
diff --git a/driver/src/rest_api.rs b/driver/src/rest_api.rs
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use async_trait::async_trait;
-use chrono_tz::Tz;
+use jiff::tz::TimeZone;
 use log::info;
 use std::collections::{BTreeMap, VecDeque};
 use std::marker::PhantomData;
@@ -333,7 +333,7 @@ impl<T: FromRowStats + std::marker::Unpin> Stream for RestAPIRows<T> {
         // Therefore, we could guarantee the `/final` called before the last row.
         if self.data.len() > 1 {
             if let Some(row) = self.data.pop_front() {
-                let row = T::try_from_raw_row(row, self.schema.clone(), self.settings.timezone)?;
+                let row = T::try_from_raw_row(row, self.schema.clone(), &self.settings.timezone)?;
                 return Poll::Ready(Some(Ok(row)));
             }
         } else if self.rows.len() > 1 {
@@ -357,7 +357,7 @@ impl<T: FromRowStats + std::marker::Unpin> Stream for RestAPIRows<T> {
                     self.data.append(&mut new_data);
                 } else {
                     for batch in page.batches.into_iter() {
-                        let rows = Rows::try_from((batch, self.settings))?;
+                        let rows = Rows::try_from((batch, self.settings.clone()))?;
                         self.rows.extend(rows);
                     }
                 }
@@ -370,7 +370,7 @@ impl<T: FromRowStats + std::marker::Unpin> Stream for RestAPIRows<T> {
                     Poll::Ready(Some(Ok(row)))
                 } else if let Some(row) = self.data.pop_front() {
                     let row =
-                        T::try_from_raw_row(row, self.schema.clone(), self.settings.timezone)?;
+                        T::try_from_raw_row(row, self.schema.clone(), &self.settings.timezone)?;
                     Poll::Ready(Some(Ok(row)))
                 } else {
                     Poll::Ready(None)
@@ -383,7 +383,8 @@ impl<T: FromRowStats + std::marker::Unpin> Stream for RestAPIRows<T> {
 
 trait FromRowStats: Send + Sync + Clone {
     fn from_stats(stats: ServerStats) -> Self;
-    fn try_from_raw_row(row: Vec<Option<String>>, schema: SchemaRef, tz: Tz) -> Result<Self>;
+    fn try_from_raw_row(row: Vec<Option<String>>, schema: SchemaRef, tz: &TimeZone)
+        -> Result<Self>;
     fn from_row(row: Row) -> Self;
 }
 
@@ -392,7 +393,11 @@ impl FromRowStats for RowWithStats {
         RowWithStats::Stats(stats)
     }
 
-    fn try_from_raw_row(row: Vec<Option<String>>, schema: SchemaRef, tz: Tz) -> Result<Self> {
+    fn try_from_raw_row(
+        row: Vec<Option<String>>,
+        schema: SchemaRef,
+        tz: &TimeZone,
+    ) -> Result<Self> {
         Ok(RowWithStats::Row(Row::try_from((schema, row, tz))?))
     }
     fn from_row(row: Row) -> Self {
@@ -405,7 +410,11 @@ impl FromRowStats for RawRowWithStats {
         RawRowWithStats::Stats(stats)
     }
 
-    fn try_from_raw_row(row: Vec<Option<String>>, schema: SchemaRef, tz: Tz) -> Result<Self> {
+    fn try_from_raw_row(
+        row: Vec<Option<String>>,
+        schema: SchemaRef,
+        tz: &TimeZone,
+    ) -> Result<Self> {
         let rows = Row::try_from((schema, row.clone(), tz))?;
         Ok(RawRowWithStats::Row(RawRow::new(rows, row)))
     }
diff --git a/sql/Cargo.toml b/sql/Cargo.toml
@@ -33,7 +33,7 @@ itertools = "0.14"
 lexical-core = "1.0.5"
 memchr = "2.7"
 roaring = { version = "0.10.12", features = ["serde"] }
-jiff = "0.2.10"
+jiff = { version = "0.2.10", features = ["tzdb-bundle-always"] }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde_json = { version = "1.0", default-features = false, features = ["std"] }
 url = { version = "2.5", default-features = false }
diff --git a/sql/src/raw_rows.rs b/sql/src/raw_rows.rs
@@ -18,8 +18,8 @@ use crate::rows::Row;
 use crate::rows::ServerStats;
 use crate::value::FormatOptions;
 use crate::value::Value;
-use chrono_tz::Tz;
 use databend_client::schema::SchemaRef;
+use jiff::tz::TimeZone;
 use lexical_core::WriteFloatOptionsBuilder;
 use std::pin::Pin;
 use std::task::Context;
@@ -69,10 +69,10 @@ impl RawRow {
     }
 }
 
-impl TryFrom<(SchemaRef, Vec<Option<String>>, Tz)> for RawRow {
+impl TryFrom<(SchemaRef, Vec<Option<String>>, &TimeZone)> for RawRow {
     type Error = Error;
 
-    fn try_from((schema, data, tz): (SchemaRef, Vec<Option<String>>, Tz)) -> Result<Self> {
+    fn try_from((schema, data, tz): (SchemaRef, Vec<Option<String>>, &TimeZone)) -> Result<Self> {
         let mut values: Vec<Value> = Vec::with_capacity(data.len());
         for (field, val) in schema.fields().iter().zip(data.clone().into_iter()) {
             values.push(Value::try_from((&field.data_type, val, tz))?);
diff --git a/sql/src/rows.rs b/sql/src/rows.rs
@@ -22,9 +22,9 @@ use tokio_stream::{Stream, StreamExt};
 use crate::error::{Error, Result};
 use crate::value::Value;
 use arrow::record_batch::RecordBatch;
-use chrono_tz::Tz;
 use databend_client::schema::SchemaRef;
 use databend_client::ResultFormatSettings;
+use jiff::tz::TimeZone;
 
 #[derive(Clone, Debug)]
 pub enum RowWithStats {
@@ -135,10 +135,10 @@ impl Row {
     }
 }
 
-impl TryFrom<(SchemaRef, Vec<Option<String>>, Tz)> for Row {
+impl TryFrom<(SchemaRef, Vec<Option<String>>, &TimeZone)> for Row {
     type Error = Error;
 
-    fn try_from((schema, data, tz): (SchemaRef, Vec<Option<String>>, Tz)) -> Result<Self> {
+    fn try_from((schema, data, tz): (SchemaRef, Vec<Option<String>>, &TimeZone)) -> Result<Self> {
         let mut values: Vec<Value> = Vec::with_capacity(data.len());
         for (field, val) in schema.fields().iter().zip(data.into_iter()) {
             values.push(Value::try_from((&field.data_type, val, tz))?);
@@ -194,7 +194,7 @@ impl TryFrom<(RecordBatch, ResultFormatSettings)> for Rows {
             for j in 0..batch_schema.fields().len() {
                 let v = batch.column(j);
                 let field = batch_schema.field(j);
-                let value = Value::try_from((field, v, i, settings))?;
+                let value = Value::try_from((field, v, i, &settings))?;
                 values.push(value);
             }
             rows.push(Row::new(schema.clone(), values));
diff --git a/sql/src/value/arrow_decoder.rs b/sql/src/value/arrow_decoder.rs
@@ -67,7 +67,7 @@ impl
         &ArrowField,
         &Arc<dyn ArrowArray>,
         usize,
-        ResultFormatSettings,
+        &ResultFormatSettings,
     )> for Value
 {
     type Error = Error;
@@ -76,7 +76,7 @@ impl
             &ArrowField,
             &Arc<dyn ArrowArray>,
             usize,
-            ResultFormatSettings,
+            &ResultFormatSettings,
         ),
     ) -> std::result::Result<Self, Self::Error> {
         if let Some(extend_type) = field.metadata().get(EXTENSION_KEY) {
@@ -349,12 +349,7 @@ impl
                                 let timestamp = Timestamp::from_microsecond(ts).map_err(|e| {
                                     Error::Parsing(format!("Invalid timestamp_micros {ts}: {e}"))
                                 })?;
-                                let tz_name = settings.timezone.name();
-                                let dt = timestamp.in_tz(tz_name).map_err(|e| {
-                                    Error::Parsing(format!(
-                                        "Invalid timezone {tz_name} for timestamp {ts}: {e}"
-                                    ))
-                                })?;
+                                let dt = timestamp.to_zoned(settings.timezone.clone());
                                 Ok(Value::Timestamp(dt))
                             }
                             Some(tz) => Err(ConvertError::new("timestamp", format!("{array:?}"))
diff --git a/sql/src/value/string_decoder.rs b/sql/src/value/string_decoder.rs
@@ -20,22 +20,21 @@ use crate::cursor_ext::{
 };
 use crate::error::{ConvertError, Result};
 use chrono::{Datelike, NaiveDate};
-use chrono_tz::Tz;
 use databend_client::schema::{DataType, DecimalDataType, DecimalSize, NumberDataType};
 use ethnum::i256;
 use hex;
-use jiff::{civil::DateTime as JiffDateTime, Zoned};
+use jiff::{civil::DateTime as JiffDateTime, tz::TimeZone, Zoned};
 use std::io::{BufRead, Cursor};
 use std::str::FromStr;
 
 const NULL_VALUE: &str = "NULL";
 const TRUE_VALUE: &str = "1";
 const FALSE_VALUE: &str = "0";
 
-impl TryFrom<(&DataType, Option<String>, Tz)> for Value {
+impl TryFrom<(&DataType, Option<String>, &TimeZone)> for Value {
     type Error = Error;
 
-    fn try_from((t, v, tz): (&DataType, Option<String>, Tz)) -> Result<Self> {
+    fn try_from((t, v, tz): (&DataType, Option<String>, &TimeZone)) -> Result<Self> {
         match v {
             Some(v) => Self::try_from((t, v, tz)),
             None => match t {
@@ -49,10 +48,10 @@ impl TryFrom<(&DataType, Option<String>, Tz)> for Value {
     }
 }
 
-impl TryFrom<(&DataType, String, Tz)> for Value {
+impl TryFrom<(&DataType, String, &TimeZone)> for Value {
     type Error = Error;
 
-    fn try_from((t, v, tz): (&DataType, String, Tz)) -> Result<Self> {
+    fn try_from((t, v, tz): (&DataType, String, &TimeZone)) -> Result<Self> {
         match t {
             DataType::Null => Ok(Self::Null),
             DataType::EmptyArray => Ok(Self::EmptyArray),
@@ -114,7 +113,9 @@ impl TryFrom<(&DataType, String, Tz)> for Value {
             DataType::Interval => Ok(Self::Interval(v)),
             DataType::Array(_) | DataType::Map(_) | DataType::Tuple(_) | DataType::Vector(_) => {
                 let mut reader = Cursor::new(v.as_str());
-                let decoder = ValueDecoder { timezone: tz };
+                let decoder = ValueDecoder {
+                    timezone: tz.clone(),
+                };
                 decoder.read_field(t, &mut reader)
             }
             DataType::Nullable(inner) => match inner.as_ref() {
@@ -134,7 +135,7 @@ impl TryFrom<(&DataType, String, Tz)> for Value {
 }
 
 struct ValueDecoder {
-    pub timezone: Tz,
+    pub timezone: TimeZone,
 }
 
 impl ValueDecoder {
@@ -299,7 +300,7 @@ impl ValueDecoder {
         let mut buf = Vec::new();
         reader.read_quoted_text(&mut buf, b'\'')?;
         let v = unsafe { std::str::from_utf8_unchecked(&buf) };
-        parse_timestamp(v, self.timezone)
+        parse_timestamp(v, &self.timezone)
     }
 
     fn read_timestamp_tz<R: AsRef<[u8]>>(&self, reader: &mut Cursor<R>) -> Result<Value> {
@@ -453,10 +454,12 @@ impl ValueDecoder {
     }
 }
 
-fn parse_timestamp(ts_string: &str, tz: Tz) -> Result<Value> {
+fn parse_timestamp(ts_string: &str, tz: &TimeZone) -> Result<Value> {
     let local = JiffDateTime::strptime(TIMESTAMP_FORMAT, ts_string)?;
-    let dt_with_tz = local.in_tz(tz.name()).map_err(|e| {
-        Error::Parsing(format!("time {ts_string} not exists in timezone {tz}: {e}"))
+    let dt_with_tz = local.to_zoned(tz.clone()).map_err(|e| {
+        Error::Parsing(format!(
+            "time {ts_string} not exists in timezone {tz:?}: {e}"
+        ))
     })?;
     Ok(Value::Timestamp(dt_with_tz))
 }
