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

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


The following commit(s) were added to refs/heads/master by this push:
     new 52d4268d55b Fix microsecond conversion of datetimes before 1970 with a 
fractional second
52d4268d55b is described below

commit 52d4268d55bd0e9893d0f409ffdc005406cb9e47
Author: Jackie Tien <[email protected]>
AuthorDate: Mon Nov 16 15:05:20 2026 +0800

    Fix microsecond conversion of datetimes before 1970 with a fractional second
---
 .../apache/iotdb/db/utils/DateTimeUtilsTest.java   | 99 +++++++++++++++++-----
 .../commons/queryengine/utils/DateTimeUtils.java   |  5 +-
 2 files changed, 83 insertions(+), 21 deletions(-)

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 0e48ffb883a..784585ab799 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
@@ -186,25 +186,86 @@ public class DateTimeUtilsTest {
 
   @Test
   public void getInstantWithPrecisionTest() {
-    Assert.assertEquals(
-        7000000000L, DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, 
"s", "ns"));
-    Assert.assertEquals(
-        420000000000L, 
DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, "m", "ns"));
-    Assert.assertEquals(
-        25200000000000L, 
DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, "h", "ns"));
-    Assert.assertEquals(
-        604800000000000L, 
DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, "d", "ns"));
-    Assert.assertEquals(
-        4233600000000000L, 
DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, "w", "ns"));
-    Assert.assertEquals(
-        18144000000000000L, 
DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, "mo", "ns"));
-    Assert.assertEquals(
-        220752000000000000L, 
DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, "y", "ns"));
-    Assert.assertEquals(
-        7000000L, DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, 
"ms", "ns"));
-    Assert.assertEquals(
-        7000L, DataNodeDateTimeUtils.convertDurationStrToLongForTest(7, "us", 
"ns"));
-    Assert.assertEquals(7L, 
DataNodeDateTimeUtils.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_123L,
+        DateTimeUtils.getInstantWithPrecision(
+            "2019-01-02T15:13:27.689123456+08:00", "microsecond"));
+    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_000L,
+        DateTimeUtils.getInstantWithPrecision("1969-12-31T23:59:59.5+00:00", 
"microsecond"));
+    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"));
   }
 
   @Ignore
diff --git 
a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/queryengine/utils/DateTimeUtils.java
 
b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/queryengine/utils/DateTimeUtils.java
index 98bcd5c935d..5102738df70 100644
--- 
a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/queryengine/utils/DateTimeUtils.java
+++ 
b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/queryengine/utils/DateTimeUtils.java
@@ -565,9 +565,10 @@ public class DateTimeUtils {
     Instant instant = zonedDateTime.toInstant();
     if ("us".equals(timestampPrecision) || 
"microsecond".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);

Reply via email to