ebug

Author: TCeason

src/common/timezone/src/lib.rs

@@ -44,21 +44,38 @@ struct DayEntry {
 impl DayEntry {
     fn new(date: Date, tz: &TimeZone) -> Self {
         let midnight = date.to_datetime(Time::midnight());
-        let zoned = midnight
-            .to_zoned(tz.clone())
-            .expect("construct timezone lut: convert midnight to zoned");
-
-        let start_utc = zoned.timestamp().as_second();
+        let ambiguous = tz.to_ambiguous_zoned(midnight);
+        let needs_later = ambiguous.is_ambiguous();
+        let zoned = match (needs_later, ambiguous) {
+            (true, ambiguous) => ambiguous
+                .later()
+                .expect("construct timezone lut: disambiguate midnight via later transition"),
+            (false, ambiguous) => ambiguous
+                .compatible()
+                .expect("construct timezone lut: convert midnight to zoned"),
+        };
+
+        let start_ts = zoned.timestamp();
+        let start_utc = start_ts.as_second();
         let offset = zoned.offset().seconds();
 
         let mut transition_utc = None;
         let mut offset_change = 0;
 
-        if let Some(trans) = tz.following(zoned.timestamp()).next() {
+        let follow_start = start_ts
+            .saturating_sub(SignedDuration::from_secs(1))
+            .unwrap_or(start_ts);
+
+        if let Some(trans) = tz.following(follow_start).next() {
             let trans_sec = trans.timestamp().as_second();
             if trans_sec < start_utc + SECONDS_PER_DAY {
                 transition_utc = Some(trans_sec);
-                offset_change = trans.offset().seconds() - offset;
+                let before_ts = trans
+                    .timestamp()
+                    .saturating_sub(SignedDuration::from_secs(1))
+                    .unwrap_or(trans.timestamp());
+                let before_offset = tz.to_offset(before_ts).seconds();
+                offset_change = trans.offset().seconds() - before_offset;
             }
         }
 
@@ -465,4 +482,40 @@ mod tests {
         assert!(fast_utc_from_local(&tz, 1850, 1, 1, 0, 0, 0, 0).is_none());
         assert!(fast_utc_from_local(&tz, 2350, 1, 1, 0, 0, 0, 0).is_none());
     }
+
+    #[test]
+    fn lut_prefers_later_midnight_in_fold() {
+        let tz = TimeZone::get("Africa/Algiers").unwrap();
+        let midnight = date(1939, 11, 19).at(0, 0, 0, 0);
+        let amb_ts = tz.to_ambiguous_timestamp(midnight);
+        assert!(amb_ts.is_ambiguous());
+
+        let later = amb_ts.later().unwrap();
+        let before_second_midnight = later.as_microsecond() - 1;
+
+        let before_components =
+            fast_components_from_timestamp(before_second_midnight, &tz).unwrap();
+        assert_eq!(
+            (
+                before_components.year,
+                before_components.month,
+                before_components.day
+            ),
+            (1939, 11, 18)
+        );
+
+        let second_midnight_components =
+            fast_components_from_timestamp(later.as_microsecond(), &tz).unwrap();
+        assert_eq!(
+            (
+                second_midnight_components.year,
+                second_midnight_components.month,
+                second_midnight_components.day
+            ),
+            (1939, 11, 19)
+        );
+        assert_eq!(second_midnight_components.hour, 0);
+        assert_eq!(second_midnight_components.minute, 0);
+        assert_eq!(second_midnight_components.second, 0);
+    }
 }

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

@@ -183,23 +183,14 @@ macro_rules! impl_interval_year_month {
                 let original_offset = ts.offset().seconds();
 
                 if let Some(components) = fast_components_from_timestamp(us, tz) {
-                    let ts_micro = (ts.subsec_nanosecond() / 1_000) as u32;
-                    let components_match = components.year == ts.year() as i32
-                        && components.month == ts.month() as u8
-                        && components.day == ts.day() as u8
-                        && components.hour == ts.hour() as u8
-                        && components.minute == ts.minute() as u8
-                        && components.second == ts.second() as u8
-                        && components.micro == ts_micro
-                        && components.offset_seconds == original_offset;
                     let new_date = $op(
                         components.year as i16,
                         components.month as i8,
                         components.day as i8,
                         delta.as_(),
                         add_months,
                     )?;
-                    if let Some(new_ts) = fast_utc_from_local(
+                    if let Some(mut new_ts) = fast_utc_from_local(
                         tz,
                         new_date.year() as i32,
                         new_date.month() as u8,
@@ -209,15 +200,28 @@ macro_rules! impl_interval_year_month {
                         components.second,
                         components.micro,
                     ) {
-                        if components_match {
+                        if let Some(new_components) = fast_components_from_timestamp(new_ts, tz) {
+                            if new_components.offset_seconds != original_offset {
+                                let shift_secs =
+                                    (new_components.offset_seconds - original_offset) as i64;
+                                let shift_micros = shift_secs.saturating_mul(MICROS_PER_SEC);
+                                new_ts = new_ts.checked_add(shift_micros).unwrap_or_else(|| {
+                                    if shift_micros.is_negative() {
+                                        i64::MIN
+                                    } else {
+                                        i64::MAX
+                                    }
+                                });
+                            }
+                            clamp_timestamp(&mut new_ts);
                             return Ok(new_ts);
                         }
                     }
                 }
 
                 let new_date = $op(ts.year(), ts.month(), ts.day(), delta.as_(), add_months)?;
 
-                let mut local =
+                let local =
                     new_date.at(ts.hour(), ts.minute(), ts.second(), ts.subsec_nanosecond());
                 let mut zoned = match local.to_zoned(tz.clone()) {
                     Ok(z) => z,