Remove DatetimeOutputCastRule on the analytics-engine route (#5420)

## Problem
On the analytics-engine route, every datetime root column is wrapped in
`CAST(<DATE/TIME/TIMESTAMP> AS VARCHAR)` by `DatetimeOutputCastRule`.
A matching `DatetimeOutputCastRewriter` on the engine side then translates
that cast into DataFusion's `to_char` extension. Whenever the rewriter's
format string and the PPL formatter disagree (e.g. trailing `Z`, `T`
separator), users see wire-format divergence — issue #5420.

## Solution
Drop the cast rule and let the engine return real datetime cells.
The PPL response pipeline already handles datetime → string conversion
natively at the formatter layer:
- `AnalyticsExecutionEngine.convertRows` feeds engine cells
  (`LocalDateTime` / `LocalDate` / `LocalTime`) through
  `ExprValueUtils.fromObjectValue`, which produces
  `ExprTimestampValue` / `ExprDateValue` / `ExprTimeValue`.
- Their `value()` methods render the documented PPL space-separated
  format (`yyyy-MM-dd HH:mm:ss[.SSSSSSSSS]` etc.).

The companion change in `opensearch-project/OpenSearch` removes the
matching `DatetimeOutputCastRewriter` and its callsites.

## Changes
- Delete `DatetimeOutputCastRule`.
- Drop the unused `UdtMapping.isDatetimeType` helper.
- Rewrite the four cast-shape assertions in `DatetimeExtensionTest`
  to assert the post-removal RelNode (no `CAST(... VARCHAR)` wrapper,
  schema reports `DATE` / `TIME` / `TIMESTAMP`).

Signed-off-by: Eric Wei <ericwei@amazon.com>

Author: mengweieric

api/src/main/java/org/opensearch/sql/api/spec/datetime/DatetimeExtension.java

@@ -22,7 +22,7 @@ public class DatetimeExtension implements LanguageExtension {
 
   @Override
   public List<RelShuttle> postAnalysisRules() {
-    return List.of(DatetimeUdtNormalizeRule.INSTANCE, DatetimeOutputCastRule.INSTANCE);
+    return List.of(DatetimeUdtNormalizeRule.INSTANCE);
   }
 
   /** Maps datetime UDT types to their standard Calcite equivalents. */
@@ -44,10 +44,5 @@ static Optional<UdtMapping> fromUdtType(RelDataType type) {
       ExprUDT udt = e.getUdt();
       return Arrays.stream(values()).filter(u -> u.udtType == udt).findFirst();
     }
-
-    /** Returns true if the given SqlTypeName is a standard datetime type. */
-    static boolean isDatetimeType(SqlTypeName typeName) {
-      return Arrays.stream(values()).anyMatch(u -> u.stdType == typeName);
-    }
   }
 }

api/src/main/java/org/opensearch/sql/api/spec/datetime/DatetimeOutputCastRule.java

@@ -63,7 +63,7 @@ private Table createEventsTable() {
   }
 
   @Test
-  public void testUdfResultNormalizedAndCastToVarchar() {
+  public void testUdfResultNormalized() {
     givenQuery(
             """
             source = catalog.events \
@@ -72,9 +72,8 @@ public void testUdfResultNormalizedAndCastToVarchar() {
             """)
         .assertPlan(
             """
-            LogicalProject(d=[CAST($0):VARCHAR], t=[CAST($1):VARCHAR], ts=[CAST($2):VARCHAR])
-              LogicalProject(d=[DATE($1)], t=[TIME($1)], ts=[TIMESTAMP($1)])
-                LogicalTableScan(table=[[catalog, events]])
+            LogicalProject(d=[DATE($1)], t=[TIME($1)], ts=[TIMESTAMP($1)])
+              LogicalTableScan(table=[[catalog, events]])
             """)
         .assertReturnType("DATE", DATE)
         .assertReturnType("TIME", TIME, 9)
@@ -94,13 +93,12 @@ public void testNestedUdfCallsNormalized() {
   }
 
   @Test
-  public void testDateLiteralCastToVarchar() {
+  public void testDateLiteralNormalized() {
     givenQuery("source = catalog.events | eval d = DATE('2024-01-01') | fields d")
         .assertPlan(
             """
-            LogicalProject(d=[CAST($0):VARCHAR])
-              LogicalProject(d=[DATE('2024-01-01':VARCHAR)])
-                LogicalTableScan(table=[[catalog, events]])
+            LogicalProject(d=[DATE('2024-01-01':VARCHAR)])
+              LogicalTableScan(table=[[catalog, events]])
             """)
         .assertReturnType("DATE", DATE);
   }
@@ -134,13 +132,12 @@ public void testComparisonWithDatetimeUdf() {
   }
 
   @Test
-  public void testAllStandardDatetimeTypesCastToVarchar() {
+  public void testStandardDatetimeFieldsNotWrapped() {
     givenQuery("source = catalog.events | fields hire_date, start_time, created_at")
         .assertPlan(
             """
-            LogicalProject(hire_date=[CAST($0):VARCHAR NOT NULL], start_time=[CAST($1):VARCHAR NOT NULL], created_at=[CAST($2):VARCHAR NOT NULL])
-              LogicalProject(hire_date=[$2], start_time=[$3], created_at=[$4])
-                LogicalTableScan(table=[[catalog, events]])
+            LogicalProject(hire_date=[$2], start_time=[$3], created_at=[$4])
+              LogicalTableScan(table=[[catalog, events]])
             """);
   }
 
@@ -155,19 +152,16 @@ public void testNonDatetimeFieldsNotWrapped() {
   }
 
   @Test
-  public void testOutputCastCanCompileAndExecute() throws Exception {
+  public void testDatetimeFieldsPreserveStandardTypes() throws Exception {
     RelNode plan =
         planner.plan("source = catalog.events | fields hire_date, start_time, created_at");
     try (PreparedStatement statement = compiler.compile(plan)) {
       ResultSet resultSet = statement.executeQuery();
       verify(resultSet)
           .expectSchema(
-              col("hire_date", java.sql.Types.VARCHAR),
-              col("start_time", java.sql.Types.VARCHAR),
-              col("created_at", java.sql.Types.VARCHAR))
-          .expectData(
-              row("2024-01-16", "12:00:00", "2024-01-15 08:00:00"),
-              row("2024-06-20", "14:00:00", "2024-06-20 00:00:00"));
+              col("hire_date", java.sql.Types.DATE),
+              col("start_time", java.sql.Types.TIME),
+              col("created_at", java.sql.Types.TIMESTAMP));
     }
   }
 }