Fixed ResultSet.getObject() for StringValue

Author: chernser

CHANGELOG.md

@@ -157,6 +157,11 @@ of `NULL` was not set and read. (https://github.com/ClickHouse/clickhouse-java/i
 
 - **[jdbc-v2, client-v2]** Fixed writing nullable marker for nested `Tuple` and `Map values. (https://github.com/ClickHouse/clickhouse-java/issues/2721)
 
+- **[jdbc-v2]** Fixed `ResultSet.getObject` leaking the internal `StringValue` holder for `String`/`FixedString`
+  columns when `binary_string_support` is enabled. `getObject(column, byte[].class)` now returns the exact raw bytes,
+  and `getObject(column, Object.class)` and the no-type `getObject(column)` overloads now return a decoded `String`
+  instead of the internal holder.
+
 ## 0.9.8
 
 ### Improvements 

docs/features.md

@@ -68,7 +68,7 @@ Compatibility-sensitive traits:
 - SQL parsing and classification: Classifies SQL to distinguish queries, updates, inserts, `USE`, and role-changing statements, with selectable parser backends.
 - JDBC escape processing: Translates supported JDBC escape syntax for dates, timestamps, and functions before execution.
 - Result set streaming: Streams result sets from ClickHouse binary formats and `FORMAT JSONEachRow`, enforces max-row limits, and manages result-set lifecycle correctly.
-- Binary string reads: `ResultSet#getBytes(int|String)` and `ResultSet#getBinaryStream(int|String)` return the raw bytes of a `String`/`FixedString` column. Combined with the `binary_string_support` connection property, non-UTF-8/binary content stored in `String` columns round-trips byte-for-byte; `NULL` values report `null` with `wasNull()` set.
+- Binary string reads: `ResultSet#getBytes(int|String)` and `ResultSet#getBinaryStream(int|String)` return the raw bytes of a `String`/`FixedString` column. Combined with the `binary_string_support` connection property, non-UTF-8/binary content stored in `String` columns round-trips byte-for-byte; `NULL` values report `null` with `wasNull()` set. `ResultSet#getObject(...)` never exposes the internal `StringValue` holder for these columns: `getObject(column, byte[].class)` returns the raw bytes, while `getObject(column, Object.class)` and the no-type `getObject(column)` overloads return a decoded `String`.
 - Result-set metadata: Exposes JDBC `ResultSetMetaData` backed by ClickHouse column schema.
 - Database metadata: Implements JDBC `DatabaseMetaData` for ClickHouse catalogs, schemas, tables, columns, and related capability reporting.
 - Parameter metadata: Reports prepared-statement parameter counts.

jdbc-v2/src/main/java/com/clickhouse/jdbc/internal/JdbcUtils.java

@@ -3,6 +3,7 @@
 import com.clickhouse.client.api.DataTypeUtils;
 import com.clickhouse.client.api.data_formats.internal.BinaryStreamReader;
 import com.clickhouse.client.api.data_formats.internal.InetAddressConverter;
+import com.clickhouse.client.api.data_formats.internal.StringValue;
 import com.clickhouse.data.ClickHouseColumn;
 import com.clickhouse.data.ClickHouseDataType;
 import com.clickhouse.data.Tuple;
@@ -12,6 +13,7 @@
 import java.net.Inet4Address;
 import java.net.Inet6Address;
 import java.net.InetAddress;
+import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.sql.Date;
 import java.sql.JDBCType;
@@ -291,6 +293,11 @@ public static Object convert(Object value, Class<?> type, ClickHouseColumn colum
             return value;
         }
 
+        // Special case
+        if (value instanceof StringValue && type == Object.class) {
+            return ((StringValue)value).asString();
+        }
+
         type = unwrapPrimitiveType(type);
         if (type.isInstance(value)) {
             return value;
@@ -344,6 +351,12 @@ static Object convertObject(Object value, Class<?> type, ClickHouseColumn column
         try {
             if (type == String.class) {
                 return value.toString();
+            } else if (type == byte[].class && value instanceof StringValue) {
+                // Raw bytes of a String/FixedString column read as a StringValue (binary_string_support).
+                // String and numeric targets already work through the value.toString() branches below.
+                return ((StringValue) value).toByteArray();
+            } else if (type == byte[].class && value instanceof String) {
+                return ((String)value).getBytes(StandardCharsets.UTF_8);
             } else if (type == Boolean.class) {
                 String str = value.toString();
                 return !("false".equalsIgnoreCase(str) || "0".equalsIgnoreCase(str));

jdbc-v2/src/test/java/com/clickhouse/jdbc/JdbcDataTypeTests.java

@@ -1539,6 +1539,7 @@ public void testStringsUsedAsBytes() throws Exception {
             for (String[] expected : testData) {
                 assertTrue(rs.next());
                 assertEquals(new String(rs.getBytes("str"), "UTF-8"), expected[0]);
+                assertEquals(new String(rs.getObject("str", byte[].class), "UTF-8"), expected[0]);
                 assertEquals(new String(rs.getBytes("fixed"), "UTF-8").replace("\0", ""), expected[1]);
             }
             assertFalse(rs.next());
@@ -1634,6 +1635,50 @@ public void testBinaryStringSupportGetBinaryStream() throws Exception {
         }
     }
 
+    @Test(groups = { "integration" })
+    public void testBinaryStringSupportGetObject() throws Exception {
+        // With binary_string_support enabled the read path returns an internal StringValue holder for
+        // String/FixedString columns. getObject must never leak that holder: it should return a decoded
+        // String for Object.class and the no-type overload, and exact raw bytes for byte[].class.
+        runQuery("CREATE TABLE test_binary_string_get_object (id Int8, str String, txt String) ENGINE = MergeTree ORDER BY ()");
+
+        String text = "Hello, ClickHouse!";
+        try (Connection conn = getJdbcConnection();
+             PreparedStatement insert = conn.prepareStatement("INSERT INTO test_binary_string_get_object VALUES (?, ?, ?)")) {
+            insert.setInt(1, 1);
+            insert.setBytes(2, CH_LOGO_PNG);
+            insert.setString(3, text);
+            insert.executeUpdate();
+        }
+
+        Properties props = new Properties();
+        props.put(ClientConfigProperties.BINARY_STRING_SUPPORT.getKey(), "true");
+
+        try (Connection conn = getJdbcConnection(props);
+             Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery("SELECT * FROM test_binary_string_get_object ORDER BY id")) {
+            assertTrue(rs.next());
+
+            // byte[].class must return the exact bytes without lossy decoding
+            Object bytesObj = rs.getObject("str", byte[].class);
+            assertTrue(bytesObj instanceof byte[], "getObject(byte[].class) should return byte[], got: " + bytesObj.getClass().getName());
+            assertEqualsToClickHouseLogo((byte[]) bytesObj);
+            assertFalse(rs.wasNull());
+
+            // Object.class must return a decoded String, not the internal StringValue holder
+            Object textObj = rs.getObject("txt", Object.class);
+            assertTrue(textObj instanceof String, "getObject(Object.class) should return String, got: " + textObj.getClass().getName());
+            assertEquals(textObj, text);
+
+            // The no-type overload must also return a String
+            Object defaultObj = rs.getObject("txt");
+            assertTrue(defaultObj instanceof String, "getObject() should return String, got: " + defaultObj.getClass().getName());
+            assertEquals(defaultObj, text);
+
+            assertFalse(rs.next());
+        }
+    }
+
     @Test(groups = { "integration" })
     public void testNestedArrays() throws Exception {
         try (Connection conn = getJdbcConnection()) {