This is an automated email from the ASF dual-hosted git repository.

JackieTien97 pushed a commit to branch dev/1.3
in repository https://gitbox.apache.org/repos/asf/iotdb.git


The following commit(s) were added to refs/heads/dev/1.3 by this push:
     new 1d4c511a90f [To dev/1.3] Fix microsecond conversion of datetimes 
before 1970 with a fractional second
1d4c511a90f is described below

commit 1d4c511a90f9dbb0f8f90f8c98654132fe0b84cb
Author: Jackie Tien <[email protected]>
AuthorDate: Mon Nov 16 17:33:13 2026 +0800

    [To dev/1.3] Fix microsecond conversion of datetimes before 1970 with a 
fractional second
---
 .../org/apache/iotdb/db/utils/DateTimeUtils.java   |  5 +-
 .../apache/iotdb/db/utils/DateTimeUtilsTest.java   | 88 ++++++++++++++++++----
 2 files changed, 76 insertions(+), 17 deletions(-)

diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/DateTimeUtils.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/DateTimeUtils.java
index f4cfa58e2b7..7a373933190 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/DateTimeUtils.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/DateTimeUtils.java
@@ -507,9 +507,10 @@ public class DateTimeUtils {
       Instant instant = zonedDateTime.toInstant();
       if ("us".equals(timestampPrecision)) {
         if (instant.getEpochSecond() < 0 && instant.getNano() > 0) {
-          // adjustment can reduce the loss of the division
+          // Same as Instant#toEpochMilli: multiply (epochSecond + 1) so that 
the product cannot
+          // overflow near Long.MIN_VALUE, then subtract that extra second 
(1_000_000 us).
           long millis = Math.multiplyExact(instant.getEpochSecond() + 1, 
1000_000L);
-          long adjustment = instant.getNano() / 1000 - 1L;
+          long adjustment = instant.getNano() / 1000 - 1_000_000L;
           return Math.addExact(millis, adjustment);
         } else {
           long millis = Math.multiplyExact(instant.getEpochSecond(), 
1000_000L);
diff --git 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/utils/DateTimeUtilsTest.java
 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/utils/DateTimeUtilsTest.java
index ea8ae9e0a31..dcad9c0f34c 100644
--- 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/utils/DateTimeUtilsTest.java
+++ 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/utils/DateTimeUtilsTest.java
@@ -153,21 +153,79 @@ public class DateTimeUtilsTest {
 
   @Test
   public void getInstantWithPrecisionTest() {
-    Assert.assertEquals(7000000000L, 
DateTimeUtils.convertDurationStrToLongForTest(7, "s", "ns"));
-    Assert.assertEquals(420000000000L, 
DateTimeUtils.convertDurationStrToLongForTest(7, "m", "ns"));
-    Assert.assertEquals(
-        25200000000000L, DateTimeUtils.convertDurationStrToLongForTest(7, "h", 
"ns"));
-    Assert.assertEquals(
-        604800000000000L, DateTimeUtils.convertDurationStrToLongForTest(7, 
"d", "ns"));
-    Assert.assertEquals(
-        4233600000000000L, DateTimeUtils.convertDurationStrToLongForTest(7, 
"w", "ns"));
-    Assert.assertEquals(
-        18144000000000000L, DateTimeUtils.convertDurationStrToLongForTest(7, 
"mo", "ns"));
-    Assert.assertEquals(
-        220752000000000000L, DateTimeUtils.convertDurationStrToLongForTest(7, 
"y", "ns"));
-    Assert.assertEquals(7000000L, 
DateTimeUtils.convertDurationStrToLongForTest(7, "ms", "ns"));
-    Assert.assertEquals(7000L, 
DateTimeUtils.convertDurationStrToLongForTest(7, "us", "ns"));
-    Assert.assertEquals(7L, DateTimeUtils.convertDurationStrToLongForTest(7, 
"ns", "ns"));
+    // the epoch and later
+    assertEquals(0L, 
DateTimeUtils.getInstantWithPrecision("1970-01-01T00:00:00+00:00", "ms"));
+    assertEquals(0L, 
DateTimeUtils.getInstantWithPrecision("1970-01-01T00:00:00+00:00", "us"));
+    assertEquals(0L, 
DateTimeUtils.getInstantWithPrecision("1970-01-01T00:00:00+00:00", "ns"));
+    assertEquals(
+        500_000L, 
DateTimeUtils.getInstantWithPrecision("1970-01-01T00:00:00.5+00:00", "us"));
+    assertEquals(
+        1_546_413_207_689L,
+        
DateTimeUtils.getInstantWithPrecision("2019-01-02T15:13:27.689123456+08:00", 
"ms"));
+    assertEquals(
+        1_546_413_207_689_123L,
+        
DateTimeUtils.getInstantWithPrecision("2019-01-02T15:13:27.689123456+08:00", 
"us"));
+    assertEquals(
+        1_546_413_207_689_123_456L,
+        
DateTimeUtils.getInstantWithPrecision("2019-01-02T15:13:27.689123456+08:00", 
"ns"));
+
+    // whole seconds before the epoch
+    assertEquals(-1_000L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59+00:00", "ms"));
+    assertEquals(
+        -1_000_000L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59+00:00", "us"));
+    assertEquals(
+        -1_000_000_000L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59+00:00", "ns"));
+
+    // the largest instant that microsecond precision can hold, and the next 
one
+    assertEquals(
+        Long.MAX_VALUE,
+        
DateTimeUtils.getInstantWithPrecision("294247-01-10T04:00:54.775807+00:00", 
"us"));
+    Assert.assertThrows(
+        ArithmeticException.class,
+        () -> 
DateTimeUtils.getInstantWithPrecision("294247-01-10T04:00:54.775808+00:00", 
"us"));
+  }
+
+  @Test
+  public void getInstantWithPrecisionBeforeEpochWithFractionTest() {
+    assertEquals(-500L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59.5+00:00", "ms"));
+    assertEquals(
+        -500_000L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59.5+00:00", "us"));
+    assertEquals(
+        -500_000_000L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59.5+00:00", "ns"));
+    // the same instant written with a UTC+8 offset
+    assertEquals(
+        -500_000L, 
DateTimeUtils.getInstantWithPrecision("1970-01-01T07:59:59.5+08:00", "us"));
+
+    assertEquals(
+        -1L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59.999999+00:00", 
"us"));
+    assertEquals(
+        -1_000_001L,
+        
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:58.999999+00:00", 
"us"));
+    assertEquals(
+        -1L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59.999999999+00:00", 
"ns"));
+
+    // digits below the precision are rounded down, the same way for ms and us
+    assertEquals(
+        -1L, 
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59.999999+00:00", 
"ms"));
+    assertEquals(
+        -1_000_000L,
+        
DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59.000000001+00:00", 
"us"));
+  }
+
+  /** Datetime literals in SQL reach getInstantWithPrecision through this 
method. */
+  @Test
+  public void convertDatetimeStrToLongBeforeEpochWithFractionTest() {
+    assertEquals(
+        -500_000L,
+        DateTimeUtils.convertDatetimeStrToLong("1969-12-31T23:59:59.5Z", 
ZoneOffset.UTC, 0, "us"));
+    assertEquals(
+        -500_000L,
+        DateTimeUtils.convertDatetimeStrToLong("1969-12-31 23:59:59.5", 
ZoneOffset.UTC, 0, "us"));
+    // a 1970-01-01 local time in a UTC+8 session is still before the epoch
+    assertEquals(
+        -500_000L,
+        DateTimeUtils.convertDatetimeStrToLong(
+            "1970-01-01T07:59:59.500", ZoneOffset.ofHours(8), 0, "us"));
   }
 
   /** Test convert duration including natural month unit. Time includes: 
1970-01-01 ~ 1970-12-01 */

Reply via email to