[analytics-backend-datafusion] Preserve fractional seconds in DatetimeOutputCastRewriter format

Widen the format string passed to `to_char` from the seconds-only
{@code "%Y-%m-%d %H:%M:%S"} to {@code "%Y-%m-%d %H:%M:%S%.f"}. The
trailing {@code %.f} is chrono's variable-length fractional-second
specifier — a leading dot followed by 0-9 digits, omitted when the
value has no sub-second precision.

This matches PPL's legacy formatting for {@code date} and
{@code date_nanos} fields where the displayed precision tracks the
source value:

- {@code 2024-01-15T10:30:01.23456789Z} (date_nanos) →
  {@code "2024-01-15 10:30:01.23456789"} (legacy) / now
  {@code "2024-01-15 10:30:01.234567890"} (analytics route — internally
  9-digit, leading 0 because Arrow Timestamp(ns) precision is fixed)
- {@code 2025-08-01T03:47:41Z} (date)            →
  {@code "2025-08-01 03:47:41"} (both paths) — no decimal because the
  source value has no fractional component

Surfaced by `CalciteSearchCommandIT.testSearchWithDateRangeComparisons`.
Follow-up to opensearch-project/sql#5420 which the original PR (#21650)
closed with a seconds-only format that dropped the fractional digits
the tests still expect.

Signed-off-by: Kai Huang <ahkcs@amazon.com>

Author: ahkcs

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

@@ -82,9 +82,15 @@ final class DatetimeOutputCastRewriter {
     /**
      * PPL's documented timestamp output format (space separator). Mirrors the
      * format used by Calcite's reference planner so the analytics-engine path
-     * matches per-row output exactly.
+     * matches per-row output exactly. The trailing {@code %.f} is chrono's
+     * variable-length fractional-second specifier — a leading dot followed by
+     * 0-9 digits, omitted when the value has no sub-second precision. This
+     * matches PPL's legacy formatting for {@code date} and {@code date_nanos}
+     * fields where the displayed precision tracks the source value (e.g.
+     * {@code "2024-01-15 10:30:01.23456789"} for a date_nanos with 8 fractional
+     * digits, {@code "2025-08-01 03:47:41"} for a whole-second value).
      */
-    static final String PPL_TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S";
+    static final String PPL_TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S%.f";
 
     private DatetimeOutputCastRewriter() {}
 

sandbox/plugins/analytics-backend-datafusion/src/test/java/org/opensearch/be/datafusion/DatetimeOutputCastRewriterTests.java

@@ -55,8 +55,11 @@ public void setUp() throws Exception {
 
     /**
      * Motivating shape: outer Project slot is exactly {@code CAST(<TIMESTAMP> AS VARCHAR)}.
-     * Rewriter must replace it with a {@code TO_CHAR(<TIMESTAMP>, '%Y-%m-%d %H:%M:%S')}
-     * call whose result type matches the original cast's VARCHAR type.
+     * Rewriter must replace it with a {@code TO_CHAR(<TIMESTAMP>, '%Y-%m-%d %H:%M:%S%.f')}
+     * call whose result type matches the original cast's VARCHAR type. The {@code %.f}
+     * tail is chrono's variable-length fractional-seconds specifier so source values
+     * with sub-second precision (DATE_NANOS) keep their fractional digits while
+     * whole-second values display cleanly without a trailing decimal.
      */
     public void testDirectTimestampOutputCastIsRewrittenToToChar() {
         RelDataType timestampType = typeFactory.createTypeWithNullability(typeFactory.createSqlType(SqlTypeName.TIMESTAMP, 6), true);
@@ -236,11 +239,11 @@ public void testTimestampCastToCharIsUntouched() {
     }
 
     /**
-     * The format string is {@code "%Y-%m-%d %H:%M:%S"} — seconds-only — to match
-     * Calcite's reference output for {@code CAST(TIMESTAMP AS VARCHAR)}, which
-     * truncates fractional seconds. This pins that contract: a TIMESTAMP(9)
-     * source still resolves to the seconds-only format literal in the
-     * rewritten {@code TO_CHAR} call.
+     * The format string is precision-agnostic: a TIMESTAMP(0) and a TIMESTAMP(9)
+     * source both resolve to the same {@code "%Y-%m-%d %H:%M:%S%.f"} literal in the
+     * rewritten {@code TO_CHAR} call. The {@code %.f} tail handles the runtime
+     * variation — whole-second values render without a trailing decimal, sub-second
+     * values render with as many fractional digits as the source carries.
      */
     public void testTimestampPrecisionDoesNotChangeFormat() {
         RelDataType nanoTimestampType = typeFactory.createTypeWithNullability(typeFactory.createSqlType(SqlTypeName.TIMESTAMP, 9), true);
@@ -255,7 +258,7 @@ public void testTimestampPrecisionDoesNotChangeFormat() {
         RexCall call = (RexCall) ((LogicalProject) rewritten).getProjects().get(0);
         RexLiteral formatLit = (RexLiteral) call.getOperands().get(1);
         assertEquals(
-            "TIMESTAMP(9) source must still resolve to the seconds-only format — fractional seconds are dropped",
+            "Format literal is precision-agnostic — chrono's %.f handles the per-value fractional digits",
             DatetimeOutputCastRewriter.PPL_TIMESTAMP_FORMAT,
             formatLit.getValueAs(String.class)
         );