fix(core): cluster D — TIME-typed list elements format as HH:mm:ss

Companion to OpenSearch fix/ai/datetime-clusters @ 9009736c2dc.
list(<TIME-typed field>) now returns "HH:mm:ss[.fraction]" without the
1970-01-01 epoch-date prefix.

The analytics-engine path rewrites PPL list() to DataFusion's list_merge,
so the legacy ListAggFunction never fires. Instead, AnalyticsExecutionEngine
now post-processes List-typed cells in the result conversion: when an
element string matches "1970-01-01[ T]HH:mm:ss[.fraction]", only the time
portion is kept. Scalar cells are untouched, preserving the wider
timestamp-stringification regression baseline.

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

Author: vinaykpud

core/src/main/java/org/opensearch/sql/executor/analytics/AnalyticsExecutionEngine.java

@@ -12,6 +12,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.regex.Pattern;
 import org.apache.calcite.plan.RelOptUtil;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.type.RelDataType;
@@ -47,6 +48,12 @@
  */
 public class AnalyticsExecutionEngine implements ExecutionEngine {
 
+  // TIME-typed columns round-trip through Timestamp and arrive in list elements as
+  // "1970-01-01[ T]HH:mm:ss[.fraction]"; analytics-engine post-processes scalars but
+  // list-aggregation elements bypass that path (see list_merge in DataFusion).
+  private static final Pattern EPOCH_DATE_TIME_PREFIX =
+      Pattern.compile("^1970-01-01[ T](\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?)$");
+
   private final QueryPlanExecutor<RelNode, Iterable<Object[]>> planExecutor;
 
   public AnalyticsExecutionEngine(QueryPlanExecutor<RelNode, Iterable<Object[]>> planExecutor) {
@@ -234,9 +241,30 @@ private static ExprValue toExprValue(Object value, RelDataType type) {
         return ExprValueUtils.stringValue(Base64.getEncoder().encodeToString(bytes));
       }
     }
+    // List elements that look like a sentinel-epoch-prefixed time render as HH:mm:ss only.
+    if (value instanceof List<?> list) {
+      return ExprValueUtils.collectionValue(stripEpochDatePrefixInList(list));
+    }
     return ExprValueUtils.fromObjectValue(value);
   }
 
+  /**
+   * Returns a copy of {@code list} with each "1970-01-01[ T]HH:mm:ss[.fraction]" string replaced by
+   * the time portion only; non-matching elements pass through unchanged.
+   */
+  private static List<Object> stripEpochDatePrefixInList(List<?> list) {
+    List<Object> out = new ArrayList<>(list.size());
+    for (Object element : list) {
+      if (element instanceof String s) {
+        var m = EPOCH_DATE_TIME_PREFIX.matcher(s);
+        out.add(m.matches() ? m.group(1) : s);
+      } else {
+        out.add(element);
+      }
+    }
+    return out;
+  }
+
   private Schema buildSchema(List<RelDataTypeField> fields) {
     List<Schema.Column> columns = new ArrayList<>();
     for (RelDataTypeField field : fields) {

core/src/test/java/org/opensearch/sql/executor/analytics/AnalyticsExecutionEngineTest.java

@@ -237,6 +237,38 @@ void executeRelNode_binaryColumnRendersAsBase64() {
         "byte[] should base64-encode to match OpenSearch binary wire format. " + dump);
   }
 
+  /** TIME-typed list elements arrive as "1970-01-01[ T]HH:mm:ss[.frac]" — strip the prefix. */
+  @Test
+  void executeRelNode_listOfStringStripsEpochDatePrefix() {
+    SqlTypeFactoryImpl typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
+    RelDataType varchar = typeFactory.createSqlType(SqlTypeName.VARCHAR);
+    RelDataType arrayOfVarchar = typeFactory.createArrayType(varchar, -1);
+    RelDataType rowType = typeFactory.builder().add("time_list", arrayOfVarchar).build();
+    RelNode relNode = mock(RelNode.class);
+    when(relNode.getRowType()).thenReturn(rowType);
+    java.util.List<String> input =
+        Arrays.asList(
+            "1970-01-01 19:36:22",
+            "1970-01-01T02:05:25",
+            "1970-01-01 12:34:56.123456789",
+            "2020-10-13 13:00:00",
+            "hello");
+    Iterable<Object[]> rows = Collections.singletonList(new Object[] {input});
+    stubExecutorWith(relNode, rows);
+
+    QueryResponse response = executeAndCapture(relNode);
+    String dump = dumpResponse(response);
+
+    java.util.List<String> result =
+        response.getResults().get(0).tupleValue().get("time_list").collectionValue().stream()
+            .map(org.opensearch.sql.data.model.ExprValue::stringValue)
+            .toList();
+    assertEquals(
+        Arrays.asList("19:36:22", "02:05:25", "12:34:56.123456789", "2020-10-13 13:00:00", "hello"),
+        result,
+        dump);
+  }
+
   @Test
   void executeRelNode_emptyResults() {
     RelNode relNode = mockRelNode("name", SqlTypeName.VARCHAR);