Convert byte[] cells to base64 ExprStringValue for IP / BINARY fields

`AnalyticsExecutionEngine.convertRows` reaches `ExprValueUtils.fromObjectValue`
for every cell in every row. OpenSearch `ip` and `binary` fields are stored
as raw bytes, so once the analytics-engine reader (paired with OpenSearch
PR #21681 commit 4) materializes a parquet column, each cell arrives as a
Java `byte[]`. The fall-through catch-all previously threw:

    ExpressionEvaluationException: unsupported object class [B
      at ExprValueUtils.fromObjectValue(ExprValueUtils.java:168)
      at AnalyticsExecutionEngine.convertRows(AnalyticsExecutionEngine.java:128)

Every PPL query that even projects an ip column fails on the analytics route
with this error, regardless of operator or predicate.

`OpenSearchSchemaBuilder.mapFieldType` collapses both `ip` and `binary` into
Calcite `VARBINARY`, so the cell-level type system can't distinguish the two.
An earlier draft of this commit gated IP rendering on byte length (4 or 16
bytes → `ExprIpValue` via `InetAddress.getByAddress`), but that misinterprets
any 4-byte ASCII payload (e.g. `"INFO"`, `"WARN"`, `"POST"`) as a public
IPv4 address — the classic "Norway problem" applied to bytes. With no schema
context here we can't safely guess, so default to a base64-encoded
`ExprStringValue`. Typed call sites that DO know the column is `ip` should
route through `ipValue(String)` explicitly.

Once `OpenSearchSchemaBuilder` splits `ip` and `binary` into separate UDTs
(TODO already filed in that file), this branch can render IP cells in
dotted-decimal form again without the length-guessing.

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

Author: ahkcs

core/src/main/java/org/opensearch/sql/data/model/ExprValueUtils.java

@@ -164,6 +164,16 @@ public static ExprValue fromObjectValue(Object o) {
       return timestampValue(((LocalDateTime) o).toInstant(ZoneOffset.UTC));
     } else if (o instanceof TemporalAmount) {
       return intervalValue((TemporalAmount) o);
+    } else if (o instanceof byte[] bytes) {
+      // No type context here: OpenSearch `ip` and `binary` fields both collapse to
+      // VARBINARY in `OpenSearchSchemaBuilder`, so a 4- or 16-byte payload could be
+      // a genuine address or arbitrary binary that happens to be that length (4-byte
+      // ASCII strings like "INFO" or "WARN" are indistinguishable from a public IPv4
+      // address byte-for-byte). Default to a safe, unambiguous encoding. Typed call
+      // sites should route IP cells through {@link #ipValue(String)} explicitly.
+      // TODO: split `ip` and `binary` into separate UDTs upstream so this branch can
+      //   render IP cells in dotted form again. See `OpenSearchSchemaBuilder.mapFieldType`.
+      return stringValue(java.util.Base64.getEncoder().encodeToString(bytes));
     } else {
       throw new ExpressionEvaluationException("unsupported object " + o.getClass());
     }

core/src/test/java/org/opensearch/sql/data/model/ExprValueUtilsTest.java

@@ -244,6 +244,18 @@ public void constructDateAndTimeValue() {
         ExprValueUtils.fromObjectValue("2012-07-07 01:01:01", TIMESTAMP));
   }
 
+  @Test
+  public void fromObjectValue_byte_array_returns_base64_string() {
+    // Without type context the factory can't distinguish `ip` from `binary`
+    // (both collapse to VARBINARY in OpenSearchSchemaBuilder), so every byte[]
+    // is base64-encoded. Typed routing happens at the call site.
+    assertEquals(
+        new ExprStringValue("AQIDBA=="), ExprValueUtils.fromObjectValue(new byte[] {1, 2, 3, 4}));
+    assertEquals(
+        new ExprStringValue("AQIDBAU="),
+        ExprValueUtils.fromObjectValue(new byte[] {1, 2, 3, 4, 5}));
+  }
+
   @Test
   public void fromObjectValue_double_infinity_returns_null() {
     assertTrue(ExprValueUtils.fromObjectValue(Double.POSITIVE_INFINITY).isNull());