fmt

Author: TCeason

Cargo.toml

@@ -176,10 +176,10 @@ databend-common-storages-stage = { path = "src/query/storages/stage" }
 databend-common-storages-stream = { path = "src/query/storages/stream" }
 databend-common-storages-system = { path = "src/query/storages/system" }
 databend-common-telemetry = { path = "src/common/telemetry" }
+databend-common-timezone = { path = "src/common/timezone" }
 databend-common-tracing = { path = "src/common/tracing" }
 databend-common-users = { path = "src/query/users" }
 databend-common-vector = { path = "src/common/vector" }
-databend-common-timezone = { path = "src/common/timezone" }
 databend-common-version = { path = "src/common/version" }
 databend-enterprise-attach-table = { path = "src/query/ee_features/attach_table" }
 databend-enterprise-data-mask-feature = { path = "src/query/ee_features/data_mask" }

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

@@ -322,17 +322,15 @@ where T: AsRef<[u8]>
             // only date part
             if need_date {
                 Ok(DateTimeResType::Date(d))
+            } else if let Some(zoned) = fast_local_to_zoned(tz, &d, 0, 0, 0, 0) {
+                Ok(DateTimeResType::Datetime(zoned))
             } else {
-                if let Some(zoned) = fast_local_to_zoned(tz, &d, 0, 0, 0, 0) {
-                    Ok(DateTimeResType::Datetime(zoned))
-                } else {
-                    Ok(DateTimeResType::Datetime(
-                        d.to_zoned(tz.clone())
-                            .map_err_to_code(ErrorCode::BadBytes, || {
-                                format!("Failed to parse date {} as timestamp.", d)
-                            })?,
-                    ))
-                }
+                Ok(DateTimeResType::Datetime(
+                    d.to_zoned(tz.clone())
+                        .map_err_to_code(ErrorCode::BadBytes, || {
+                            format!("Failed to parse date {} as timestamp.", d)
+                        })?,
+                ))
             }
         }
     }

src/common/timezone/src/lib.rs

@@ -126,12 +126,10 @@ impl DayEntry {
                     } else {
                         return None;
                     }
+                } else if local_seconds >= transition_elapsed {
+                    elapsed = local_seconds - offset_change;
                 } else {
-                    if local_seconds >= transition_elapsed {
-                        elapsed = local_seconds - offset_change;
-                    } else {
-                        elapsed = local_seconds;
-                    }
+                    elapsed = local_seconds;
                 }
             }
         }
@@ -204,8 +202,9 @@ impl TimeZoneLut {
     }
 }
 
-static TZ_LUTS: LazyLock<RwLock<Vec<(TimeZone, Arc<TimeZoneLut>)>>> =
-    LazyLock::new(|| RwLock::new(Vec::new()));
+type LutCache = RwLock<Vec<(TimeZone, Arc<TimeZoneLut>)>>;
+
+static TZ_LUTS: LazyLock<LutCache> = LazyLock::new(|| RwLock::new(Vec::new()));
 
 fn get_or_init_lut(tz: &TimeZone) -> Arc<TimeZoneLut> {
     {
@@ -315,7 +314,7 @@ fn day_of_year(year: i32, month: u8, day: u8) -> u16 {
 }
 
 fn day_index_for_date(year: i32, month: u8, day: u8) -> Option<usize> {
-    if year < LUT_MIN_YEAR || year > LUT_MAX_YEAR {
+    if !(LUT_MIN_YEAR..=LUT_MAX_YEAR).contains(&year) {
         return None;
     }
     if month == 0 || month > 12 {
@@ -361,13 +360,14 @@ fn weeks_in_year(year: i32) -> u32 {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use jiff::tz::TimeZone;
     use jiff::Timestamp;
     use rand::rngs::StdRng;
     use rand::Rng;
     use rand::SeedableRng;
 
+    use super::*;
+
     const START_SECS: i64 = -2_208_988_800;
     const END_SECS: i64 = 10_413_792_000;
 
@@ -406,7 +406,10 @@ mod tests {
                 assert_eq!(components.minute, zoned.minute() as u8);
                 assert_eq!(components.second, zoned.second() as u8);
                 assert_eq!(components.offset_seconds, zoned.offset().seconds());
-                assert_eq!(components.day_of_year as usize, zoned.day_of_year() as usize);
+                assert_eq!(
+                    components.day_of_year as usize,
+                    zoned.day_of_year() as usize
+                );
                 assert_eq!(components.weekday, zoned.weekday());
 
                 let (iso_year, iso_week) = components.iso_year_week();
@@ -428,7 +431,11 @@ mod tests {
     ) {
         let time = jiff::civil::Time::new(hour as i8, minute as i8, second as i8, 0).unwrap();
         let dt = jiff::civil::date(year as i16, month as i8, day as i8).to_datetime(time);
-        let expected = dt.to_zoned(tz.clone()).unwrap().timestamp().as_microsecond();
+        let expected = dt
+            .to_zoned(tz.clone())
+            .unwrap()
+            .timestamp()
+            .as_microsecond();
         let actual = fast_utc_from_local(tz, year, month, day, hour, minute, second, 0)
             .expect("fast path should succeed");
         assert_eq!(expected, actual);

src/query/expression/src/utils/date_helper.rs

@@ -15,6 +15,9 @@
 use std::sync::LazyLock;
 
 use databend_common_exception::Result;
+use databend_common_timezone::fast_components_from_timestamp;
+use databend_common_timezone::fast_utc_from_local;
+use databend_common_timezone::DateTimeComponents;
 use jiff::civil::date;
 use jiff::civil::datetime;
 use jiff::civil::Date;
@@ -33,9 +36,6 @@ use num_traits::AsPrimitive;
 use crate::types::date::clamp_date;
 use crate::types::timestamp::clamp_timestamp;
 use crate::types::timestamp::MICROS_PER_SEC;
-use databend_common_timezone::fast_components_from_timestamp;
-use databend_common_timezone::fast_utc_from_local;
-use databend_common_timezone::DateTimeComponents;
 
 // jiff's `Timestamp` only accepts UTC seconds in
 // [-377705023201, 253402207200] so that any ±25:59:59 offset still
@@ -221,12 +221,7 @@ impl_interval_year_month!(EvalYearsImpl, eval_years_base);
 impl_interval_year_month!(EvalMonthsImpl, eval_months_base);
 
 fn components_time_is_before(a: &DateTimeComponents, b: &DateTimeComponents) -> bool {
-    (
-        a.hour,
-        a.minute,
-        a.second,
-        a.micro,
-    ) < (b.hour, b.minute, b.second, b.micro)
+    (a.hour, a.minute, a.second, a.micro) < (b.hour, b.minute, b.second, b.micro)
 }
 
 fn date_from_components(c: &DateTimeComponents) -> Option<Date> {
@@ -235,14 +230,12 @@ fn date_from_components(c: &DateTimeComponents) -> Option<Date> {
 
 fn datetime_from_components(c: &DateTimeComponents) -> Option<DateTime> {
     let date = date_from_components(c)?;
-    Some(
-        date.at(
-            c.hour as i8,
-            c.minute as i8,
-            c.second as i8,
-            (c.micro * 1_000) as i32,
-        ),
-    )
+    Some(date.at(
+        c.hour as i8,
+        c.minute as i8,
+        c.second as i8,
+        (c.micro * 1_000) as i32,
+    ))
 }
 
 impl EvalYearsImpl {
@@ -1237,7 +1230,7 @@ impl ToNumber<u32> for ToYYYYWW {
 
     fn from_components(components: &DateTimeComponents) -> Option<u32> {
         let (iso_year, iso_week) = components.iso_year_week();
-        Some(iso_year as u32 * 100 + iso_week as u32)
+        Some(iso_year as u32 * 100 + iso_week)
     }
 }
 
@@ -1248,7 +1241,7 @@ impl ToNumber<u8> for ToQuarter {
     }
 
     fn from_components(components: &DateTimeComponents) -> Option<u8> {
-        Some(((components.month - 1) / 3 + 1) as u8)
+        Some((components.month - 1) / 3 + 1)
     }
 }
 

src/query/expression/tests/it/types.rs

@@ -61,7 +61,10 @@ fn test_parse_jiff() {
     // that only specify a Unix timestamp (`%s`), verify via `to_timestamp`.
     let (mut tm, _) = BrokenDownTime::parse_prefix("%s", "200").unwrap();
     tm.set_offset(Some(tz::offset(0 as _)));
-    assert_eq!("1970-01-01T00:03:20Z", tm.to_timestamp().unwrap().to_string());
+    assert_eq!(
+        "1970-01-01T00:03:20Z",
+        tm.to_timestamp().unwrap().to_string()
+    );
 }
 
 #[test]

src/query/functions/src/scalars/timestamp/src/datetime.rs

@@ -61,8 +61,6 @@ use databend_common_expression::types::StringType;
 use databend_common_expression::types::TimestampType;
 use databend_common_expression::types::F64;
 use databend_common_expression::utils::date_helper::*;
-use databend_common_timezone::fast_components_from_timestamp;
-use databend_common_timezone::fast_utc_from_local;
 use databend_common_expression::vectorize_1_arg;
 use databend_common_expression::vectorize_2_arg;
 use databend_common_expression::vectorize_4_arg;
@@ -75,6 +73,8 @@ use databend_common_expression::FunctionDomain;
 use databend_common_expression::FunctionProperty;
 use databend_common_expression::FunctionRegistry;
 use databend_common_expression::Value;
+use databend_common_timezone::fast_components_from_timestamp;
+use databend_common_timezone::fast_utc_from_local;
 use dtparse::parse;
 use jiff::civil::date;
 use jiff::civil::Date;
@@ -613,16 +613,7 @@ fn fast_timestamp_from_tm(tm: &BrokenDownTime, tz: &TimeZone) -> Option<i64> {
     let second: u8 = tm.second().unwrap_or(0).try_into().ok()?;
     let nanos = tm.subsec_nanosecond().unwrap_or(0);
     let micro = (nanos / 1_000).max(0) as u32;
-    fast_utc_from_local(
-        tz,
-        year,
-        month,
-        day,
-        hour,
-        minute,
-        second,
-        micro,
-    )
+    fast_utc_from_local(tz, year, month, day, hour, minute, second, micro)
 }
 
 fn register_date_to_timestamp(registry: &mut FunctionRegistry) {
@@ -977,9 +968,8 @@ fn timestamp_days_via_lut(value: i64, tz: &TimeZone) -> Option<i32> {
 }
 
 fn days_from_components(year: i32, month: u8, day: u8) -> Option<i32> {
-    NaiveDate::from_ymd_opt(year, month as u32, day as u32).map(|d| {
-        clamp_date((d.num_days_from_ce() - EPOCH_DAYS_FROM_CE) as i64)
-    })
+    NaiveDate::from_ymd_opt(year, month as u32, day as u32)
+        .map(|d| clamp_date((d.num_days_from_ce() - EPOCH_DAYS_FROM_CE) as i64))
 }
 
 fn timestamp_days_via_jiff(value: i64, tz: &TimeZone) -> i32 {
@@ -993,10 +983,11 @@ fn timestamp_days_via_jiff(value: i64, tz: &TimeZone) -> i32 {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use chrono::NaiveDate;
     use jiff::tz::TimeZone;
 
+    use super::*;
+
     fn micros_for_utc(year: i32, month: u32, day: u32, hour: u32, minute: u32, second: u32) -> i64 {
         let naive = NaiveDate::from_ymd_opt(year, month, day)
             .unwrap()
@@ -1025,10 +1016,7 @@ mod tests {
         let tz = TimeZone::UTC;
         let past = micros_for_utc(1800, 7, 1, 0, 0, 0);
         assert!(timestamp_days_via_lut(past, &tz).is_none());
-        assert_eq!(
-            timestamp_to_date_days(past, &tz),
-            expected_days(1800, 7, 1)
-        );
+        assert_eq!(timestamp_to_date_days(past, &tz), expected_days(1800, 7, 1));
 
         let future = micros_for_utc(2400, 3, 15, 12, 0, 0);
         assert!(timestamp_days_via_lut(future, &tz).is_none());

src/query/functions/src/scalars/timestamp/src/interval.rs

@@ -30,15 +30,15 @@ use databend_common_expression::types::Int64Type;
 use databend_common_expression::types::IntervalType;
 use databend_common_expression::types::StringType;
 use databend_common_expression::types::TimestampType;
-use databend_common_timezone::fast_components_from_timestamp;
-use databend_common_timezone::DateTimeComponents;
 use databend_common_expression::vectorize_2_arg;
 use databend_common_expression::vectorize_with_builder_1_arg;
 use databend_common_expression::vectorize_with_builder_2_arg;
 use databend_common_expression::EvalContext;
 use databend_common_expression::FunctionDomain;
 use databend_common_expression::FunctionRegistry;
 use databend_common_expression::Value;
+use databend_common_timezone::fast_components_from_timestamp;
+use databend_common_timezone::DateTimeComponents;
 use jiff::tz::Offset;
 use jiff::tz::TimeZone;
 use jiff::Timestamp;
@@ -290,7 +290,7 @@ fn register_interval_add_sub_mul(registry: &mut FunctionRegistry) {
                         is_negative = true;
                     }
                     let zone1 = match Offset::from_seconds(t1.seconds_offset())
-                        .map(|offset| TimeZone::fixed(offset))
+                        .map(TimeZone::fixed)
                     {
                         Ok(zone) => zone,
                         Err(err) => {
@@ -299,7 +299,7 @@ fn register_interval_add_sub_mul(registry: &mut FunctionRegistry) {
                         }
                     };
                     let zone2 = match Offset::from_seconds(t2.seconds_offset())
-                        .map(|offset| TimeZone::fixed(offset))
+                        .map(TimeZone::fixed)
                     {
                         Ok(zone) => zone,
                         Err(err) => {