Add VARCHAR-literal regression test and trim helper comments

Cover the case where RexSimplify strips a literal's EXPR_TIMESTAMP UDT
during Sarg folding and the field is the only timestamp anchor left.
Without the fix, the raw "yyyy-MM-dd HH:mm:ss" string would ship without
format("date_time"), and the shard's default parser would reject it.

Trim the two helper-method JavaDocs to single-line `//` comments now that
the test pins the behavior.

Signed-off-by: Jialiang Liang <jiallian@amazon.com>

Author: RyanL1997

opensearch/src/main/java/org/opensearch/sql/opensearch/request/PredicateAnalyzer.java

@@ -1447,34 +1447,16 @@ public QueryExpression lte(LiteralExpression literal) {
       return this;
     }
 
-    /**
-     * Whether the comparison should be treated as a timestamp range. The field's type is the
-     * reliable source — {@code literal.isDateTime()} relies on the literal's UDT, which {@link
-     * org.apache.calcite.rex.RexSimplify} can strip when a sibling clause is folded into a {@code
-     * Sarg} (e.g. {@code @timestamp > X AND severityText IN (...)}). Without this defensive check,
-     * the literal arrives as VARCHAR, the raw string ships to the shard without {@code
-     * format("date_time")} or ISO-8601 normalization, and the shard's default date parser rejects
-     * the space-separated {@code "2026-05-28 16:18:43"} form. See #5481.
-     */
+    // Field type is the reliable source: RexSimplify can strip the literal's UDT when a sibling
+    // clause is folded into a Sarg, leaving it as VARCHAR.
     private boolean isFieldOrLiteralDateTime(LiteralExpression literal) {
       return literal.isDateTime() || (rel != null && rel.isTimeStampType());
     }
 
-    /**
-     * Resolves the comparison endpoint to a value the shard's date parser accepts. Mirrors the Sarg
-     * path's {@code convertEndpointValue} — when the field is a timestamp, the value is routed
-     * through {@link #timestampValueForPushDown} to land in canonical ISO-8601 regardless of the
-     * literal's surviving type.
-     */
     private Object endpointValue(LiteralExpression literal, boolean isTimeStamp) {
-      if (!isTimeStamp) {
-        return literal.value();
-      }
-      if (literal.isDateTime()) {
-        // literal.value() already normalizes for EXPR_TIMESTAMP / EXPR_DATE literals.
+      if (!isTimeStamp || literal.isDateTime()) {
         return literal.value();
       }
-      // Field is timestamp but literal was re-typed to VARCHAR — normalize the raw value.
       return timestampValueForPushDown(literal.value().toString());
     }
 

opensearch/src/test/java/org/opensearch/sql/opensearch/request/PredicateAnalyzerTest.java

@@ -1147,6 +1147,38 @@ void notEquals_generatesBoolQueryForDateTime() throws ExpressionNotAnalyzableExc
         result.toString());
   }
 
+  /**
+   * RexSimplify can strip the EXPR_TIMESTAMP UDT off a literal when a sibling clause is folded into
+   * a Sarg (e.g. {@code @timestamp > X AND severityText IN (...)}), leaving the literal as plain
+   * VARCHAR. The comparison must still emit a {@code format("date_time")} range query keyed off the
+   * field's type so the shard's default date parser accepts the value.
+   */
+  @Test
+  void gt_normalizesVarcharLiteralAgainstTimestampField()
+      throws ExpressionNotAnalyzableException {
+    RexLiteral varcharLiteral = (RexLiteral) builder.makeLiteral("1987-02-03 04:34:56");
+    RexNode call = builder.makeCall(SqlStdOperatorTable.GREATER_THAN, field4, varcharLiteral);
+    QueryBuilder result = PredicateAnalyzer.analyze(call, schema, fieldTypes);
+
+    assertInstanceOf(RangeQueryBuilder.class, result);
+    assertEquals(
+        """
+        {
+          "range" : {
+            "d" : {
+              "from" : "1987-02-03T04:34:56.000Z",
+              "to" : null,
+              "include_lower" : false,
+              "include_upper" : true,
+              "format" : "date_time",
+              "boost" : 1.0
+            }
+          }
+        }\
+        """,
+        result.toString());
+  }
+
   @Test
   void gte_generatesRangeQueryWithFormatForDateTime() throws ExpressionNotAnalyzableException {
     RexNode call =