Convert byte[] cells to ExprValue in fromObjectValue 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 (post-#21681 commit 4)
materializes a parquet column, each cell arrives as a Java `byte[]`. The
fall-through catch-all then throws:

    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. Length is the only signal available — IPv4 is exactly 4 bytes,
IPv6 is exactly 16, and `InetAddress.getByAddress` rejects every other
length, so the heuristic is unambiguous in practice:

  - 4 or 16 bytes → ExprIpValue (canonical IP string)
  - any other length → base64-encoded ExprStringValue (binary payload)

`InetAddress.getByAddress` may throw `UnknownHostException` only when the
length is not 4 or 16; we already gate on that, but the catch is kept as a
defensive fall-through to base64 for forward compatibility (e.g. future
RFC 6052-style 4or16-byte alternates).

Future work: differentiate `ip` and `binary` at the schema layer (separate
UDTs in `OpenSearchSchemaBuilder` + matching `schema_coerce.rs` handling)
so the type system can route directly without the length heuristic. Tracked
by the TODO already in `OpenSearchSchemaBuilder.mapFieldType`.

Adds three unit tests in `ExprValueUtilsTest` covering IPv4, IPv6, and
non-IP byte arrays.

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

Author: ahkcs

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

@@ -164,6 +164,23 @@ 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) {
+      // OpenSearch `ip` and `binary` fields both map to Calcite VARBINARY in
+      // `OpenSearchSchemaBuilder`, so by the time the cell reaches this factory the
+      // type system can't distinguish the two. Length is the only signal — IPv4 is
+      // 4 bytes, IPv6 is 16, and `InetAddress.getByAddress` rejects every other
+      // length, so we can safely try it first and fall through to base64 for
+      // genuine `binary` payloads.
+      // TODO: differentiate `ip` and `binary` upstream (separate UDTs in
+      //   `OpenSearchSchemaBuilder` + `schema_coerce.rs`) and route by type here.
+      if (bytes.length == 4 || bytes.length == 16) {
+        try {
+          return new ExprIpValue(java.net.InetAddress.getByAddress(bytes).getHostAddress());
+        } catch (java.net.UnknownHostException ignored) {
+          // Fall through to base64.
+        }
+      }
+      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,33 @@ public void constructDateAndTimeValue() {
         ExprValueUtils.fromObjectValue("2012-07-07 01:01:01", TIMESTAMP));
   }
 
+  @Test
+  public void fromObjectValue_ipv4_byte_array_returns_ip_value() {
+    // 1.2.3.4
+    byte[] ipv4 = new byte[] {1, 2, 3, 4};
+    ExprValue v = ExprValueUtils.fromObjectValue(ipv4);
+    assertTrue(v instanceof ExprIpValue);
+    assertEquals("1.2.3.4", v.value());
+  }
+
+  @Test
+  public void fromObjectValue_ipv6_byte_array_returns_ip_value() {
+    // ::1 (loopback)
+    byte[] ipv6 = new byte[16];
+    ipv6[15] = 1;
+    ExprValue v = ExprValueUtils.fromObjectValue(ipv6);
+    assertTrue(v instanceof ExprIpValue);
+    assertEquals("::1", v.value());
+  }
+
+  @Test
+  public void fromObjectValue_non_ip_byte_array_returns_base64_string() {
+    // 5-byte payload — not a valid IP length, falls through to base64.
+    byte[] binary = new byte[] {1, 2, 3, 4, 5};
+    ExprValue v = ExprValueUtils.fromObjectValue(binary);
+    assertEquals(new ExprStringValue("AQIDBAU="), v);
+  }
+
   @Test
   public void fromObjectValue_double_infinity_returns_null() {
     assertTrue(ExprValueUtils.fromObjectValue(Double.POSITIVE_INFINITY).isNull());