From ff07fe0d028424b38e443ce81f51a9d640c515a9 Mon Sep 17 00:00:00 2001 From: ccq <76206374+caichangqing1120@users.noreply.github.com> Date: Fri, 25 Sep 2026 22:49:26 +0800 Subject: [PATCH] fix(duckdb): render timestamptz with session time zone --- agents/drivers/duckdb/Cargo.lock | 1 + agents/drivers/duckdb/Cargo.toml | 1 + agents/drivers/duckdb/src/query.rs | 154 ++++++++++++++++++++++++++++- 3 files changed, 152 insertions(+), 4 deletions(-) diff --git a/agents/drivers/duckdb/Cargo.lock b/agents/drivers/duckdb/Cargo.lock index 7d4df119aa..469f0f73cf 100644 --- a/agents/drivers/duckdb/Cargo.lock +++ b/agents/drivers/duckdb/Cargo.lock @@ -1543,6 +1543,7 @@ name = "dbx-duckdb-driver" version = "0.1.0" dependencies = [ "chrono", + "chrono-tz", "dbx-core", "duckdb", "log", diff --git a/agents/drivers/duckdb/Cargo.toml b/agents/drivers/duckdb/Cargo.toml index eaf36a19e3..5b1a243ec9 100644 --- a/agents/drivers/duckdb/Cargo.toml +++ b/agents/drivers/duckdb/Cargo.toml @@ -24,6 +24,7 @@ test = false [dependencies] chrono = "0.4" +chrono-tz = "0.10" duckdb = { version = "1.3.2", features = ["bundled", "parquet"] } log = "0.4" serde = { version = "1", features = ["derive"] } diff --git a/agents/drivers/duckdb/src/query.rs b/agents/drivers/duckdb/src/query.rs index eeec0267cf..a226940ffe 100644 --- a/agents/drivers/duckdb/src/query.rs +++ b/agents/drivers/duckdb/src/query.rs @@ -1,6 +1,8 @@ #![allow(clippy::items_after_test_module)] -use chrono::{DateTime, Duration as ChronoDuration, NaiveDate, NaiveDateTime, NaiveTime, Utc}; +use chrono::{DateTime, Duration as ChronoDuration, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, Offset, Utc}; +use chrono_tz::Tz; +use duckdb::core::LogicalTypeId; use duckdb::types::{TimeUnit, Value, ValueRef}; use crate::wire as db; @@ -179,6 +181,53 @@ mod tests { ]] ); } + + #[test] + fn duckdb_execute_preserves_timezone_marker_only_for_timestamptz() { + let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB"); + con.execute_batch("SET TimeZone = 'Asia/Shanghai'").expect("set session timezone"); + con.execute_batch("CREATE VIEW events AS SELECT TIMESTAMPTZ '2025-02-10 20:37:56+00' AS occurred_at") + .expect("create view"); + + let result = duckdb_execute( + &con, + "SELECT occurred_at, occurred_at::VARCHAR AS session_value, \ + TIMESTAMP '2025-02-10 20:37:56' AS naive_value, \ + NULL::TIMESTAMPTZ AS missing_value, \ + TIMESTAMPTZ '2025-02-10 20:37:56.123456+00' AS precise_value FROM events", + ) + .expect("query view with temporal values"); + + assert_eq!(result.rows[0][0], serde_json::json!("2025-02-11 04:37:56+08")); + assert_eq!(result.rows[0][1], serde_json::json!("2025-02-11 04:37:56+08")); + assert_eq!(result.rows[0][2], serde_json::json!("2025-02-10 20:37:56")); + assert_eq!(result.rows[0][3], serde_json::Value::Null); + assert_eq!(result.rows[0][4], serde_json::json!("2025-02-11 04:37:56.123456+08")); + } + + #[test] + fn duckdb_execute_uses_dst_offset_for_each_instant() { + let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB"); + con.execute_batch("SET TimeZone = 'America/New_York'").expect("set session timezone"); + let result = duckdb_execute( + &con, + "SELECT TIMESTAMPTZ '2025-01-15 12:00:00+00' AS winter, TIMESTAMPTZ '2025-07-15 12:00:00+00' AS summer", + ) + .expect("execute timestamptz query"); + + assert_eq!(result.rows[0][0], serde_json::json!("2025-01-15 07:00:00-05")); + assert_eq!(result.rows[0][1], serde_json::json!("2025-07-15 08:00:00-04")); + } + + #[test] + fn duckdb_session_timezone_accepts_fixed_offsets() { + assert!(DuckDbSessionTimezone::parse("+08").is_some()); + assert!(DuckDbSessionTimezone::parse("-05:30").is_some()); + assert!(DuckDbSessionTimezone::parse("+24").is_none()); + assert_eq!(format_utc_offset(0), "+00"); + assert_eq!(format_utc_offset(8 * 3600), "+08"); + assert_eq!(format_utc_offset(-(5 * 3600 + 30 * 60)), "-05:30"); + } } #[cfg(test)] @@ -186,7 +235,12 @@ pub fn duckdb_execute(con: &duckdb::Connection, sql: &str) -> Result, idx: usize) -> serde_json::Value { +fn duckdb_value_to_json( + row: &duckdb::Row<'_>, + idx: usize, + timestamptz: bool, + session_timezone: Option, +) -> serde_json::Value { let Ok(value_ref) = row.get_ref(idx) else { return serde_json::Value::Null; }; @@ -216,7 +270,12 @@ fn duckdb_value_to_json(row: &duckdb::Row<'_>, idx: usize) -> serde_json::Value duckdb_time64_to_string(unit, value).map(serde_json::Value::String).unwrap_or(serde_json::Value::Null) } ValueRef::Timestamp(unit, value) => { - duckdb_timestamp_to_string(unit, value).map(serde_json::Value::String).unwrap_or(serde_json::Value::Null) + let formatted = if timestamptz { + duckdb_timestamptz_to_string(unit, value, session_timezone) + } else { + duckdb_timestamp_to_string(unit, value) + }; + formatted.map(serde_json::Value::String).unwrap_or(serde_json::Value::Null) } ValueRef::Text(bytes) => std::str::from_utf8(bytes) .map(|s| serde_json::Value::String(s.to_string())) @@ -353,6 +412,87 @@ fn duckdb_time64_to_string(unit: TimeUnit, value: i64) -> Option { Some(format_temporal_without_empty_fraction(time.to_string())) } +#[derive(Clone, Copy)] +enum DuckDbSessionTimezone { + Zone(Tz), + Fixed(FixedOffset), +} + +impl DuckDbSessionTimezone { + fn parse(name: &str) -> Option { + let name = name.trim(); + if let Ok(zone) = name.parse::() { + return Some(Self::Zone(zone)); + } + parse_fixed_utc_offset(name).map(Self::Fixed) + } + + fn to_local(self, instant: DateTime) -> (NaiveDateTime, i32) { + match self { + Self::Zone(zone) => { + let local = instant.with_timezone(&zone); + (local.naive_local(), local.offset().fix().local_minus_utc()) + } + Self::Fixed(offset) => { + let local = instant.with_timezone(&offset); + (local.naive_local(), local.offset().fix().local_minus_utc()) + } + } + } +} + +fn parse_fixed_utc_offset(value: &str) -> Option { + let (sign, rest) = match value.as_bytes().first()? { + b'+' => (1, &value[1..]), + b'-' => (-1, &value[1..]), + _ => return None, + }; + let (hours, minutes) = match rest.split_once(':') { + Some((hours, minutes)) => (hours.parse::().ok()?, minutes.parse::().ok()?), + None if rest.len() == 4 => (rest[..2].parse::().ok()?, rest[2..].parse::().ok()?), + None if rest.len() <= 2 => (rest.parse::().ok()?, 0), + None => return None, + }; + if !(0..=23).contains(&hours) || !(0..=59).contains(&minutes) { + return None; + } + FixedOffset::east_opt(sign * (hours * 3600 + minutes * 60)) +} + +fn duckdb_session_timezone(con: &duckdb::Connection) -> Option { + let name: String = con.query_row("SELECT current_setting('TimeZone')", [], |row| row.get(0)).ok()?; + DuckDbSessionTimezone::parse(&name) +} + +fn duckdb_timestamptz_to_string( + unit: TimeUnit, + value: i64, + session_timezone: Option, +) -> Option { + let nanos = duckdb_time_unit_to_nanos(unit, value)?; + let seconds = nanos.div_euclid(1_000_000_000); + let nanos_remainder = nanos.rem_euclid(1_000_000_000) as u32; + let instant: DateTime = DateTime::from_timestamp(seconds, nanos_remainder)?; + Some(match session_timezone { + Some(session_timezone) => { + let (local, offset_seconds) = session_timezone.to_local(instant); + format!("{}{}", format_naive_datetime(local), format_utc_offset(offset_seconds)) + } + None => format!("{}+00", format_naive_datetime(instant.naive_utc())), + }) +} + +fn format_utc_offset(offset_seconds: i32) -> String { + let sign = if offset_seconds < 0 { '-' } else { '+' }; + let total_minutes = offset_seconds.unsigned_abs() / 60; + let (hours, minutes) = (total_minutes / 60, total_minutes % 60); + if minutes == 0 { + format!("{sign}{hours:02}") + } else { + format!("{sign}{hours:02}:{minutes:02}") + } +} + fn duckdb_timestamp_to_string(unit: TimeUnit, value: i64) -> Option { let nanos = duckdb_time_unit_to_nanos(unit, value)?; let seconds = nanos.div_euclid(1_000_000_000); @@ -397,6 +537,8 @@ pub fn duckdb_execute_with_max_rows( let sql = sql.as_ref(); if crate::sql::starts_with_duckdb_result_sql_keyword(sql) { + // DuckDB cannot answer another query while a result set is being streamed. + let session_timezone = duckdb_session_timezone(con); let mut stmt = con.prepare(sql).map_err(|e| e.to_string())?; let mut rows = stmt.query([]).map_err(|e| e.to_string())?; let stmt_ref = rows.as_ref().ok_or("DuckDB statement unavailable")?; @@ -404,10 +546,14 @@ pub fn duckdb_execute_with_max_rows( let columns: Vec = (0..col_count) .map(|i| stmt_ref.column_name(i).map(|s| s.to_string()).unwrap_or_else(|_| "?".to_string())) .collect(); + let timestamptz_columns: Vec = + (0..col_count).map(|i| stmt_ref.column_logical_type(i).id() == LogicalTypeId::TimestampTZ).collect(); let mut result_rows = Vec::new(); while let Some(row) = rows.next().map_err(|e| e.to_string())? { - let vals: Vec = (0..col_count).map(|i| duckdb_value_to_json(row, i)).collect(); + let vals: Vec = (0..col_count) + .map(|i| duckdb_value_to_json(row, i, timestamptz_columns[i], session_timezone)) + .collect(); result_rows.push(vals); if result_rows.len() > row_limit { break;