Floor-divide DATEDIFF day-numbers for pre-1970 correctness

SQL `/` truncates toward zero, so naive `to_unixtime(x) / 86400` rounds
negative epoch seconds the wrong way and puts e.g. `1969-12-31 12:00`
on the same epoch-day as `1970-01-01 00:00`. Express the floor in pure
integer arithmetic — `(x - ((x MOD d + d) MOD d)) / d` — since isthmus
has no `FLOOR(i64)` signature in the bound catalog. Pin with two
DateTimeScalarFunctionsIT cases that span and sit below the epoch.

Signed-off-by: Vinay Krishna Pudyodu <vinkrish.neo@gmail.com>

Author: vinaykpud

sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/DateDiffAdapter.java

@@ -58,10 +58,15 @@ public RexNode adapt(RexCall original, List<FieldStorageInfo> fieldStorage, RelO
     }
 
     /**
-     * {@code to_unixtime(x) / 86400} — the epoch-day index of {@code x}. {@code to_unixtime} returns
-     * BIGINT whole seconds, so the divide is integer division (truncates toward zero); for the UTC
-     * epoch seconds of any post-1970 date that equals {@code floor}, giving the calendar-day index.
-     * No explicit FLOOR — isthmus has no {@code FLOOR(i64)} signature.
+     * Epoch-day index of {@code x} via floor-division of {@code to_unixtime(x) / 86400}.
+     * {@code to_unixtime} returns BIGINT whole seconds; SQL integer division truncates toward zero,
+     * which differs from floor for negative epoch seconds (pre-1970 dates) — so naïve {@code x / d}
+     * would put e.g. {@code 1969-12-31 12:00:00} on the same day index as {@code 1970-01-01 00:00:00}
+     * and skew {@code DATEDIFF} across the epoch. Isthmus has no {@code FLOOR(i64)} signature, so
+     * the floor is expressed in pure integer arithmetic:
+     * <pre>{@code   floor(x / d) = (x - ((x MOD d + d) MOD d)) / d}</pre>
+     * The bracketed term is the non-negative remainder; subtracting it makes the numerator a
+     * multiple of {@code d}, so the trailing divide is exact regardless of {@code x}'s sign.
      *
      * <p>A bare {@code TIME} operand (e.g. {@code DATEDIFF(TIME('23:59:59'), TIME('00:00:00'))}) is
      * anchored to a TIMESTAMP first via {@link DatePartAdapters#coerceCharacterOperandToTimestamp},
@@ -77,6 +82,12 @@ private static RexNode dayNumber(RexNode operand, RelOptCluster cluster) {
             BigDecimal.valueOf(TimeOfDayLowering.SECONDS_PER_DAY),
             rexBuilder.getTypeFactory().createSqlType(SqlTypeName.BIGINT)
         );
-        return rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE, epochSeconds, secondsPerDay);
+        // floorMod = ((x MOD d) + d) MOD d — non-negative remainder.
+        RexNode mod1 = rexBuilder.makeCall(SqlStdOperatorTable.MOD, epochSeconds, secondsPerDay);
+        RexNode plusDay = rexBuilder.makeCall(SqlStdOperatorTable.PLUS, mod1, secondsPerDay);
+        RexNode floorMod = rexBuilder.makeCall(SqlStdOperatorTable.MOD, plusDay, secondsPerDay);
+        // numerator = x - floorMod, which is exactly divisible by d.
+        RexNode numerator = rexBuilder.makeCall(SqlStdOperatorTable.MINUS, epochSeconds, floorMod);
+        return rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE, numerator, secondsPerDay);
     }
 }

sandbox/qa/analytics-engine-rest/src/test/java/org/opensearch/analytics/qa/DateTimeScalarFunctionsIT.java

@@ -458,6 +458,26 @@ public void testDateDiffIgnoresTimeOfDay() throws IOException {
         );
     }
 
+    /**
+     * DATEDIFF across the Unix epoch boundary — pins the floor-divide. Naïve integer division
+     * (truncating toward zero) would put both operands on day 0 and return 0; floor-divide
+     * correctly assigns 1969-12-31 to day -1, giving the expected 1-day delta.
+     */
+    public void testDateDiffAcrossEpochBoundary() throws IOException {
+        assertFirstRowLong(
+            oneRow("key00") + "| eval d = datediff('1970-01-01 00:00:00', '1969-12-31 12:00:00') | fields d",
+            1L
+        );
+    }
+
+    /** DATEDIFF on a pre-1970 pair — both operands negative-epoch, floor-divide preserves the calendar delta. */
+    public void testDateDiffPre1970Pair() throws IOException {
+        assertFirstRowLong(
+            oneRow("key00") + "| eval d = datediff('1969-12-31 00:00:00', '1969-12-30 00:00:00') | fields d",
+            1L
+        );
+    }
+
     /**
      * DATEDIFF on two TIME operands: both anchor to the same (today's UTC) date, so their day-counts
      * cancel — matches MySQL's documented behavior of returning 0 even when the time-of-day values