Truncate negative millisecond fractions (#71)

benches/main.rs

@@ -248,3 +248,25 @@ fn format_date_time(bench: &mut Bencher) {
         black_box(date.to_string());
     })
 }
+
+#[bench]
+fn parse_timestamp_str(bench: &mut Bencher) {
+    let timestamps = black_box([
+        "1654646400",
+        "-1654646400",
+        "1654646404",
+        "-1654646404",
+        "1654646404.5",
+        "1654646404.123456",
+        "1654646404000.5",
+        "1654646404123.456",
+        "-1654646404.123456",
+        "-1654646404000.123",
+    ]);
+
+    bench.iter(|| {
+        for timestamp in &timestamps {
+            black_box(DateTime::parse_str(black_box(*timestamp)).unwrap());
+        }
+    });
+}

src/datetime.rs

@@ -1,5 +1,7 @@
 use crate::date::MS_WATERSHED;
-use crate::{int_parse_bytes, MicrosecondsPrecisionOverflowBehavior, TimeConfigBuilder};
+use crate::{
+    float_parse_bytes, numbers::decimal_digits, IntFloat, MicrosecondsPrecisionOverflowBehavior, TimeConfigBuilder,
+};
 use crate::{time::TimeConfig, Date, ParseError, Time};
 use std::cmp::Ordering;
 use std::fmt;
@@ -339,50 +341,41 @@ impl DateTime {
     pub fn parse_bytes_with_config(bytes: &[u8], config: &TimeConfig) -> Result<Self, ParseError> {
         match Self::parse_bytes_rfc3339_with_config(bytes, config) {
             Ok(d) => Ok(d),
-            Err(e) => {
-                let mut split = bytes.splitn(2, |&b| b == b'.');
-                let Some(timestamp) =
-                    int_parse_bytes(split.next().expect("splitn always returns at least one element"))
-                else {
-                    return Err(e);
-                };
-                let float_fraction = split.next();
-                debug_assert!(split.next().is_none()); // at most two elements
-                match float_fraction {
-                    // If fraction exists but is empty (i.e. trailing `.`), allow for backwards compatibility;
-                    // TODO might want to reconsider this later?
-                    Some(b"") | None => Self::from_timestamp_with_config(timestamp, 0, config),
-                    Some(fract) => {
-                        // fraction is either:
-                        // - up to 3 digits of millisecond fractions, i.e. microseconds
-                        // - or up to 6 digits of second fractions, i.e. milliseconds
-                        let max_digits = if timestamp > MS_WATERSHED { 3 } else { 6 };
-                        let Some(fract_integers) = int_parse_bytes(fract) else {
-                            return Err(e);
-                        };
-                        if config.microseconds_precision_overflow_behavior
-                            == MicrosecondsPrecisionOverflowBehavior::Error
-                            && fract.len() > max_digits
-                        {
-                            return Err(if timestamp > MS_WATERSHED {
-                                ParseError::MillisecondFractionTooLong
-                            } else {
-                                ParseError::SecondFractionTooLong
-                            });
+            Err(e) => match float_parse_bytes(bytes) {
+                IntFloat::Int(int) => Self::from_timestamp_with_config(int, 0, config),
+                IntFloat::Float(float) => {
+                    let timestamp_in_milliseconds = float.abs() > MS_WATERSHED as f64;
+
+                    if config.microseconds_precision_overflow_behavior == MicrosecondsPrecisionOverflowBehavior::Error {
+                        let decimal_digits_count = decimal_digits(bytes);
+
+                        // If the number of decimal digits exceeds the maximum allowed for the timestamp precision,
+                        // return an error. For timestamps in milliseconds, the maximum is 3, for timestamps in seconds,
+                        // the maximum is 6. These end up being the same in terms of allowing microsecond precision.
+                        if timestamp_in_milliseconds && decimal_digits_count > 3 {
+                            return Err(ParseError::MillisecondFractionTooLong);
+                        } else if !timestamp_in_milliseconds && decimal_digits_count > 6 {
+                            return Err(ParseError::SecondFractionTooLong);
                         }
-                        // TODO: Technically this is rounding, but this is what the existing
-                        // behaviour already did. Probably this is always better than "truncating"
-                        // so we might want to change MicrosecondsPrecisionOverflowBehavior and
-                        // make other uses also round / deprecate truncating.
-                        let multiple = 10f64.powf(max_digits as f64 - fract.len() as f64);
-                        Self::from_timestamp_with_config(
-                            timestamp,
-                            (fract_integers as f64 * multiple).round() as u32,
-                            config,
-                        )
                     }
+
+                    let timestamp_normalized: f64 = if timestamp_in_milliseconds {
+                        float / 1_000f64
+                    } else {
+                        float
+                    };
+
+                    // if seconds is negative, we round down (left on the number line), so -6.25 -> -7
+                    // which allows for a positive number of microseconds to compensate back up to -6.25
+                    // which is the equivalent of doing (seconds - 1) and (microseconds + 1_000_000)
+                    // like we do in Date::timestamp_watershed
+                    let seconds = timestamp_normalized.floor() as i64;
+                    let microseconds = ((timestamp_normalized - seconds as f64) * 1_000_000f64).round() as u32;
+
+                    Self::from_timestamp_with_config(seconds, microseconds, config)
                 }
-            }
+                IntFloat::Err => Err(e),
+            },
         }
     }
 

src/numbers.rs

@@ -115,3 +115,13 @@ pub fn float_parse_bytes(s: &[u8]) -> IntFloat {
         IntFloat::Int(int_part)
     }
 }
+
+/// Count the number of decimal places in a byte slice.
+/// Caution: does not verify the integrity of the input,
+/// so it may return incorrect results for invalid inputs.
+pub(crate) fn decimal_digits(bytes: &[u8]) -> usize {
+    match bytes.splitn(2, |&b| b == b'.').nth(1) {
+        Some(b"") | None => 0,
+        Some(fraction) => fraction.len(),
+    }
+}

tests/main.rs

@@ -863,10 +863,14 @@ param_tests! {
     dt_underscore: ok => "2020-01-01_12:13:14,123z", "2020-01-01T12:13:14.123000Z";
     dt_unix1: ok => "1654646400", "2022-06-08T00:00:00";
     dt_unix2: ok => "1654646404", "2022-06-08T00:00:04";
+    dt_unix_1_neg: ok => "-1654646400", "1917-07-27T00:00:00";
+    dt_unix_2_neg: ok => "-1654646404", "1917-07-26T23:59:56";
     dt_unix_float: ok => "1654646404.5", "2022-06-08T00:00:04.500000";
     dt_unix_float_limit: ok => "1654646404.123456", "2022-06-08T00:00:04.123456";
     dt_unix_float_ms: ok => "1654646404000.5", "2022-06-08T00:00:04.000500";
     dt_unix_float_ms_limit: ok => "1654646404123.456", "2022-06-08T00:00:04.123456";
+    dt_unix_float_ms_neg: ok => "-1654646404.123456", "1917-07-26T23:59:55.876544";
+    dt_unix_float_ms_neg_limit: ok => "-1654646404000.123", "1917-07-26T23:59:55.999877";
     dt_unix_float_empty: ok => "1654646404.", "2022-06-08T00:00:04";
     dt_unix_float_ms_empty: ok => "1654646404000.", "2022-06-08T00:00:04";
     dt_unix_float_too_long: err => "1654646404.1234567", SecondFractionTooLong;