refactor: Timestamp(i64, tz) -> Timestamp(DateTime<Tz>) (#715)

* ci: make output of ttc server with arrow consist with http handler.

* chore: fix cargo deny

* refactor: Timestamp(i64, tz) ->  Timestamp(DateTime<Tz>)

Author: youngsofun

bindings/nodejs/Cargo.toml

@@ -14,7 +14,6 @@ doc = false
 
 [dependencies]
 chrono = { workspace = true }
-chrono-tz = { workspace = true }
 databend-driver = { workspace = true, features = ["rustls", "flight-sql"] }
 env_logger = "0.11.8"
 tokio-stream = { workspace = true }

bindings/nodejs/src/lib.rs

@@ -16,7 +16,6 @@
 extern crate napi_derive;
 
 use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime};
-use chrono_tz::Tz;
 use databend_driver::LoadMethod;
 use napi::{bindgen_prelude::*, Env};
 use once_cell::sync::Lazy;
@@ -317,11 +316,7 @@ impl ToNapiValue for Value<'_> {
             databend_driver::Value::Number(n) => {
                 NumberValue::to_napi_value(env, NumberValue(n.clone()))
             }
-            databend_driver::Value::Timestamp(_, _tz) => {
-                let inner = val.inner.clone();
-                let v = DateTime::<Tz>::try_from(inner).map_err(format_napi_error)?;
-                DateTime::to_napi_value(env, v)
-            }
+            databend_driver::Value::Timestamp(dt) => DateTime::to_napi_value(env, *dt),
             databend_driver::Value::TimestampTz(dt) => {
                 let formatted = dt.format(TIMESTAMP_TIMEZONE_FORMAT);
                 String::to_napi_value(env, formatted.to_string())

bindings/python/Cargo.toml

@@ -14,7 +14,6 @@ doc = false
 
 [dependencies]
 chrono = { workspace = true }
-chrono-tz = { workspace = true }
 databend-client = { workspace = true }
 databend-driver = { workspace = true, features = ["rustls", "flight-sql"] }
 databend-driver-core = { workspace = true }

bindings/python/src/types.rs

@@ -18,8 +18,7 @@ use std::sync::Arc;
 use chrono::offset::Offset;
 #[cfg(feature = "cp38")]
 use chrono::FixedOffset;
-use chrono::{DateTime, Duration, NaiveDate};
-use chrono_tz::Tz;
+use chrono::{Duration, NaiveDate};
 use once_cell::sync::Lazy;
 use pyo3::exceptions::{PyAttributeError, PyException, PyStopAsyncIteration, PyStopIteration};
 use pyo3::sync::GILOnceCell;
@@ -78,19 +77,15 @@ impl<'py> IntoPyObject<'py> for Value {
                 let v = NumberValue(n);
                 v.into_bound_py_any(py)?
             }
-            databend_driver::Value::Timestamp(_, _) => {
-                let t = DateTime::<Tz>::try_from(self.0).map_err(|e| {
-                    PyException::new_err(format!("failed to convert timestamp: {e}"))
-                })?;
+            databend_driver::Value::Timestamp(dt) => {
                 #[cfg(feature = "cp38")]
                 {
                     // chrono_tz -> PyDateTime isn't implemented for Python < 3.9 (no zoneinfo).
-                    let t: DateTime<FixedOffset> = t.with_timezone(&t.offset().fix());
-                    t.into_bound_py_any(py)?
+                    dt.with_timezone(&dt.offset().fix()).into_bound_py_any(py)?
                 }
                 #[cfg(not(feature = "cp38"))]
                 {
-                    t.into_bound_py_any(py)?
+                    dt.into_bound_py_any(py)?
                 }
             }
             databend_driver::Value::TimestampTz(t) => t.into_bound_py_any(py)?,

bindings/python/tests/blocking/steps/binding.py

@@ -176,7 +176,9 @@ def _(context):
         )
         exp = datetime(2024, 4, 16, 12, 34, 56, 789000, tzinfo=tz_expected)
         exp_bug = datetime(2024, 4, 16, 18, 34, 56, 789000, tzinfo=tz_expected)
-        if DB_VERSION >= (1, 2, 840) and not os.getenv("BODY_FORMAT") == "arrow":
+        if (DB_VERSION >= (1, 2, 840) and not os.getenv("BODY_FORMAT") == "arrow") or (
+            DB_VERSION >= (1, 2, 844) and os.getenv("BODY_FORMAT") == "arrow"
+        ):
             assert row.values()[0] == exp, f"timestamp_tz: {row.values()[0]} {exp}"
         else:
             assert row.values()[0] == exp_bug, (

cli/Cargo.toml

@@ -28,7 +28,7 @@ ctrlc = { version = "3.4.6", features = ["termination"] }
 databend-common-ast = "0.2.3"
 dirs = "5.0"
 fern = { version = "0.7", features = ["colored"] }
-indicatif = "0.17"
+indicatif = "0.18.3"
 log = "0.4"
 mime_guess = "2.0"
 nom = "8.0.0"

cli/src/display.rs

@@ -839,7 +839,7 @@ fn value_display_width(value: &Value, quote_string: bool) -> usize {
         Value::EmptyArray => EMPTY_WIDTH,
         Value::EmptyMap => EMPTY_WIDTH,
         Value::Date(_) => DATE_WIDTH,
-        Value::Timestamp(_, _) => TIMESTAMP_WIDTH,
+        Value::Timestamp(_) => TIMESTAMP_WIDTH,
         Value::String(_) => {
             let value_str = value.to_string();
             if quote_string {

driver/tests/driver/select_simple.rs

@@ -16,6 +16,7 @@ use std::assert_eq;
 use std::collections::HashMap;
 
 use chrono::{DateTime, NaiveDate, NaiveDateTime};
+use chrono_tz::Tz;
 use databend_driver::{params, Client, Connection, DecimalSize, NumberValue, Value};
 
 use crate::common::DEFAULT_DSN;
@@ -195,8 +196,8 @@ async fn select_datetime() {
     assert!(row.is_some());
     let row = row.unwrap();
     {
-        let (val,): (i64,) = row.clone().try_into().unwrap();
-        assert_eq!(val, 1680006896789000);
+        let (val,): (DateTime<Tz>,) = row.clone().try_into().unwrap();
+        assert_eq!(val.timestamp_micros(), 1680006896789000);
     }
     {
         let (val,): (NaiveDateTime,) = row.try_into().unwrap();

sql/src/raw_rows.rs

@@ -16,14 +16,25 @@ use crate::error::Error;
 use crate::error::Result;
 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 lexical_core::WriteFloatOptionsBuilder;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 use tokio_stream::{Stream, StreamExt};
 
+pub static HTTP_HANDLER_OPTIONS: FormatOptions = FormatOptions {
+    true_string: b"1",
+    false_string: b"0",
+    float_options: WriteFloatOptionsBuilder::new()
+        .nan_string(Some(b"NaN"))
+        .inf_string(Some(b"Infinity"))
+        .build_unchecked(),
+};
+
 #[derive(Clone, Debug)]
 pub enum RawRowWithStats {
     Row(RawRow),
@@ -76,7 +87,7 @@ impl From<Row> for RawRow {
     fn from(row: Row) -> Self {
         let mut raw_row: Vec<Option<String>> = Vec::with_capacity(row.values().len());
         for val in row.values() {
-            raw_row.push(Some(val.to_string()));
+            raw_row.push(Some(val.to_string_with_options(&HTTP_HANDLER_OPTIONS)));
         }
         RawRow::new(row, raw_row)
     }

sql/src/value/arrow_decoder.rs

@@ -22,7 +22,7 @@ use arrow_array::{
     StructArray, TimestampMicrosecondArray, UInt16Array, UInt32Array, UInt64Array, UInt8Array,
 };
 use arrow_schema::{DataType as ArrowDataType, Field as ArrowField, TimeUnit};
-use chrono::{FixedOffset, TimeZone};
+use chrono::{FixedOffset, LocalResult, TimeZone};
 use chrono_tz::Tz;
 use databend_client::schema::{
     DecimalSize, ARROW_EXT_TYPE_BITMAP, ARROW_EXT_TYPE_EMPTY_ARRAY, ARROW_EXT_TYPE_EMPTY_MAP,
@@ -327,7 +327,18 @@ impl TryFrom<(&ArrowField, &Arc<dyn ArrowArray>, usize, Tz)> for Value {
                         }
                         let ts = array.value(seq);
                         match tz {
-                            None => Ok(Value::Timestamp(ts, ltz)),
+                            None => {
+                                let dt = match ltz.timestamp_micros(ts) {
+                                    LocalResult::Single(dt) => dt,
+                                    LocalResult::None => {
+                                        return Err(Error::Parsing(format!(
+                                            "time {ts} not exists in timezone {ltz}"
+                                        )))
+                                    }
+                                    LocalResult::Ambiguous(dt1, _dt2) => dt1,
+                                };
+                                Ok(Value::Timestamp(dt))
+                            }
                             Some(tz) => Err(ConvertError::new("timestamp", format!("{array:?}"))
                                 .with_message(format!("non-UTC timezone not supported: {tz:?}"))
                                 .into()),