bendsql todo

Author: TCeason

Cargo.lock

@@ -13,6 +13,7 @@ borsh = { workspace = true }
 byteorder = { workspace = true }
 bytes = { workspace = true }
 chrono = { workspace = true }
+chrono-tz = { workspace = true }
 databend-common-base = { workspace = true }
 databend-common-exception = { workspace = true }
 databend-common-timezone = { workspace = true }

src/common/io/Cargo.toml

@@ -19,10 +19,10 @@ use chrono::Datelike;
 use chrono::NaiveDate;
 use chrono::NaiveDateTime;
 use chrono::Timelike;
+use chrono_tz::Tz;
 use databend_common_exception::ErrorCode;
 use databend_common_exception::Result;
 use databend_common_exception::ToErrorCode;
-use databend_common_timezone::Tz;
 use databend_common_timezone::fast_utc_from_local;
 
 use crate::cursor_ext::cursor_read_bytes_ext::ReadBytesExt;
@@ -65,7 +65,23 @@ fn days_from_epoch(date: &NaiveDate) -> i32 {
         .num_days() as i32
 }
 
-fn local_to_micros(tz: &Tz, local: &NaiveDateTime, micro: u32) -> Option<i64> {
+fn local_to_micros_checked(
+    tz: &Tz,
+    local: &NaiveDateTime,
+    micro: u32,
+    provided_offset: Option<i32>,
+) -> Result<i64> {
+    // Explicit offsets are independent of the session timezone and its DST gaps.
+    if let Some(offset) = provided_offset {
+        return local
+            .and_utc()
+            .timestamp()
+            .checked_sub(i64::from(offset))
+            .and_then(|seconds| seconds.checked_mul(MICROS_PER_SEC))
+            .and_then(|micros| micros.checked_add(i64::from(micro)))
+            .ok_or_else(|| ErrorCode::BadBytes("Datetime offset adjustment overflowed"));
+    }
+
     fast_utc_from_local(
         tz,
         local.year(),
@@ -76,28 +92,14 @@ fn local_to_micros(tz: &Tz, local: &NaiveDateTime, micro: u32) -> Option<i64> {
         local.second() as u8,
         micro,
     )
-}
-
-fn local_to_micros_checked(tz: &Tz, local: &NaiveDateTime, micro: u32) -> Result<i64> {
-    local_to_micros(tz, local, micro).ok_or_else(|| {
+    .ok_or_else(|| {
         ErrorCode::BadBytes(format!(
             "Invalid local datetime {} for timezone {tz}",
             local.format("%Y-%m-%d %H:%M:%S")
         ))
     })
 }
 
-/// Explicit offsets are independent of the session timezone and its DST gaps.
-fn micros_with_offset(local: &NaiveDateTime, micro: u32, offset: i32) -> Result<i64> {
-    local
-        .and_utc()
-        .timestamp()
-        .checked_sub(i64::from(offset))
-        .and_then(|seconds| seconds.checked_mul(MICROS_PER_SEC))
-        .and_then(|micros| micros.checked_add(i64::from(micro)))
-        .ok_or_else(|| ErrorCode::BadBytes("Datetime offset adjustment overflowed"))
-}
-
 fn try_read_standard_timestamp<T: AsRef<[u8]>>(
     cursor: &mut Cursor<T>,
     tz: &Tz,
@@ -183,11 +185,7 @@ fn build_best_effort_result(
             ))
         })?;
 
-    let micros = if let Some(offset) = provided_offset {
-        micros_with_offset(&local, micro, offset)?
-    } else {
-        local_to_micros_checked(tz, &local, micro)?
-    };
+    let micros = local_to_micros_checked(tz, &local, micro, provided_offset)?;
     Ok(DateTimeResType::Datetime(micros))
 }
 
@@ -306,15 +304,14 @@ where T: AsRef<[u8]>
             v = "1970-01-01";
         }
 
-        let d = NaiveDate::parse_from_str(v, "%Y-%m-%d").map_err_to_code(
-            ErrorCode::BadBytes,
-            || {
+        let d = v
+            .parse::<NaiveDate>()
+            .map_err_to_code(ErrorCode::BadBytes, || {
                 format!(
                     "Date Parsing Error: The value '{}' could not be parsed into a valid Date",
                     v
                 )
-            },
-        )?;
+            })?;
         check_input_year(d.year())?;
 
         buf.clear();
@@ -325,7 +322,7 @@ where T: AsRef<[u8]>
             }
             let midnight = d.and_hms_opt(0, 0, 0).expect("midnight is valid");
             return Ok(DateTimeResType::Datetime(local_to_micros_checked(
-                tz, &midnight, 0,
+                tz, &midnight, 0, None,
             )?));
         }
 
@@ -360,7 +357,7 @@ where T: AsRef<[u8]>
                 return Ok(DateTimeResType::Date(days_from_epoch(&d)));
             }
             return Ok(DateTimeResType::Datetime(local_to_micros_checked(
-                tz, &local, 0,
+                tz, &local, 0, None,
             )?));
         }
 
@@ -402,11 +399,7 @@ where T: AsRef<[u8]>
             return Ok(DateTimeResType::Date(days_from_epoch(&d)));
         }
 
-        let micros = if let Some(offset) = explicit_offset {
-            micros_with_offset(&local, micro, offset)?
-        } else {
-            local_to_micros_checked(tz, &local, micro)?
-        };
+        let micros = local_to_micros_checked(tz, &local, micro, explicit_offset)?;
         Ok(DateTimeResType::Datetime(micros))
     }
 }

src/common/io/src/cursor_ext/cursor_read_datetime_ext.rs

@@ -16,8 +16,8 @@ use std::borrow::Cow;
 
 use base64::Engine as _;
 use base64::engine::general_purpose;
+use chrono_tz::Tz;
 use databend_common_exception::ErrorCode;
-use databend_common_timezone::Tz;
 
 use crate::GeometryDataType;
 

src/common/io/src/format_settings.rs

@@ -15,8 +15,8 @@
 use std::io::Cursor;
 
 use chrono::NaiveDate;
+use chrono_tz::Tz;
 use databend_common_io::cursor_ext::*;
-use databend_common_timezone::Tz;
 use databend_common_timezone::local_datetime_at;
 
 /// Render microseconds as a local datetime in `tz`, for comparison against the

src/common/io/tests/it/cursor_ext/read_datetime_ext.rs

@@ -27,7 +27,7 @@ use chrono::Offset;
 use chrono::TimeDelta;
 use chrono::TimeZone as _;
 use chrono::Utc;
-pub use chrono_tz::Tz;
+use chrono_tz::Tz;
 pub use civil::DateTimeComponents;
 pub use lut::components_from_timestamp;
 pub use lut::fast_utc_from_local;

src/common/timezone/src/lib.rs

@@ -17,7 +17,7 @@
 use chrono::LocalResult;
 use chrono::NaiveDateTime;
 use chrono::Offset;
-use chrono::TimeZone as _;
+use chrono::TimeZone;
 use chrono_tz::GapInfo;
 use chrono_tz::Tz;
 
@@ -100,10 +100,7 @@ fn resolve_named(
     }
 }
 
-fn resolved<Tz: chrono::TimeZone>(
-    unix_seconds: i64,
-    value: &chrono::DateTime<Tz>,
-) -> ResolvedLocalTime {
+fn resolved<Tz: TimeZone>(unix_seconds: i64, value: &chrono::DateTime<Tz>) -> ResolvedLocalTime {
     ResolvedLocalTime {
         unix_seconds,
         offset_seconds: value.offset().fix().local_minus_utc(),

src/common/timezone/src/resolve.rs

@@ -20,6 +20,7 @@ base64 = { workspace = true }
 borsh = { workspace = true }
 bumpalo = { workspace = true }
 chrono = { workspace = true }
+chrono-tz = { workspace = true }
 comfy-table = { workspace = true }
 databend-common-ast = { workspace = true }
 databend-common-base = { workspace = true }

src/query/expression/Cargo.toml

@@ -24,14 +24,14 @@ use std::sync::Arc;
 
 use chrono::DateTime;
 use chrono::Utc;
+use chrono_tz::Tz;
 use databend_common_ast::Span;
 use databend_common_column::bitmap::Bitmap;
 use databend_common_column::bitmap::MutableBitmap;
 use databend_common_exception::ErrorCode;
 use databend_common_exception::Result;
 use databend_common_io::GeometryDataType;
 use databend_common_io::prelude::BinaryDisplayFormat;
-use databend_common_timezone::Tz;
 use enum_as_inner::EnumAsInner;
 use itertools::Itertools;
 use serde::Deserialize;

src/query/expression/src/function.rs

@@ -17,12 +17,12 @@ use std::io::Cursor;
 
 use chrono::NaiveDate;
 use chrono::TimeDelta;
+use chrono_tz::Tz;
 use databend_common_column::buffer::Buffer;
 use databend_common_exception::ErrorCode;
 use databend_common_io::cursor_ext::BufferReadDateTimeExt;
 use databend_common_io::cursor_ext::ReadBytesExt;
 pub use databend_common_io::datetime::check_input_year;
-use databend_common_timezone::Tz;
 use num_traits::AsPrimitive;
 
 use super::ArgType;
@@ -55,6 +55,16 @@ pub fn date_from_days(days: impl AsPrimitive<i64>) -> NaiveDate {
         .expect("date day count is inside the chrono civil range")
 }
 
+/// Preserve the legacy conversion policy: either bound overflow maps to DATE_MIN.
+#[inline]
+pub fn clamp_date(days: i64) -> i32 {
+    if (DATE_MIN as i64..=DATE_MAX as i64).contains(&days) {
+        days as i32
+    } else {
+        DATE_MIN
+    }
+}
+
 /// Validate the SQL DATE range without silently changing the value.
 #[inline]
 pub fn check_date(days: i64) -> Result<i32, String> {