Fix client-v2: serialize Nested columns in RowBinary writer

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### Bug Fixes 
 
+- **[client-v2]** Fixed `RowBinaryFormatWriter` throwing `UnsupportedOperationException: Unsupported data type: Nested` when inserting into a table with an un-flattened `Nested(...)` column (created with `flatten_nested = 0`). The `RowBinary` writer now serializes a `Nested(f1 T1, ..., fN TN)` column the same way it is read — identically to `Array(Tuple(T1, ..., TN))`. (https://github.com/ClickHouse/clickhouse-java/issues/2477)
+
 - **[client-v2]** Fixed binary array decoding for nullable element types so `Array(Nullable(Float64))` and similar columns now return boxed arrays such as `Double[]` instead of `Object[]`. This keeps null-supporting arrays aligned with their element type while preserving the existing `Object[]` fallback for Variant/Dynamic/Geometry arrays. (https://github.com/ClickHouse/clickhouse-java/issues/2846)
 
 - **[client-v2]** Fixed `Float32`/`Float64` columns throwing `ClassCastException` when a value of a

client-v2/src/main/java/com/clickhouse/client/api/data_formats/internal/SerializerUtils.java

@@ -72,6 +72,9 @@ public static void serializeData(OutputStream stream, Object value, ClickHouseCo
             case Map:
                 serializeMapData(stream, value, column);
                 break;
+            case Nested:
+                serializeNestedTypeData(stream, value, column);
+                break;
             case AggregateFunction:
                 serializeAggregateFunction(stream, value, column);
                 break;
@@ -130,6 +133,25 @@ private static void serializeNestedData(OutputStream stream, Object value, Click
         serializeData(stream, value, column);
     }
 
+    /**
+     * Serializes a {@code Nested} column. In {@code RowBinary} a {@code Nested(f1 T1, ..., fN TN)}
+     * column has the same layout as {@code Array(Tuple(T1, ..., TN))}: a var-uint element count
+     * followed by that many tuples, each carrying the N field values in declaration order. The
+     * value is therefore a list (or array) of tuples, matching what
+     * {@link BinaryStreamReader#readNested(ClickHouseColumn)} produces on read.
+     */
+    private static void serializeNestedTypeData(OutputStream stream, Object value, ClickHouseColumn column) throws IOException {
+        if (value == null) {
+            writeVarInt(stream, 0);
+            return;
+        }
+        List<?> tuples = convertArrayValueToList(value);
+        writeVarInt(stream, tuples.size());
+        for (Object tuple : tuples) {
+            serializeTupleData(stream, tuple, column);
+        }
+    }
+
     private static final Map<Class<?>, ClickHouseColumn> PREDEFINED_TYPE_COLUMNS = getPredefinedTypeColumnsMap();
 
     private static Map<Class<?>, ClickHouseColumn> getPredefinedTypeColumnsMap() {

client-v2/src/test/java/com/clickhouse/client/api/data_formats/internal/SerializerUtilsTest.java

@@ -217,6 +217,44 @@
         };
     }
 
+    @Test(dataProvider = "rowBinaryTypeData")
+    public void testRowBinaryTypeRoundTrip(String typeName, Object value) throws Exception {
+        ClickHouseColumn column = ClickHouseColumn.of("v", typeName);
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        SerializerUtils.serializeData(out, value, column);
+
+        Object actual = newReader(out.toByteArray()).readValue(column);
+        Assert.assertEquals(normalize(actual), normalize(value));
+    }
+
+    @DataProvider(name = "rowBinaryTypeData")
+    private Object[][] rowBinaryTypeData() {
+        return new Object[][] {
+                // A Nested(...) column has the same RowBinary layout as Array(Tuple(...)): a
+                // var-uint row count followed by that many tuples. Two rows detect a wrong count
+                // or a dropped field byte, which would shift every following tuple.
+                {"Nested(a Int32, b String)",
+                        Arrays.asList(Arrays.asList(1, "x"), Arrays.asList(2, "y"))},
+
+                // Same value as arrays instead of Lists: an Object[][] of Object[] rows (a
+                // "matrix" array). convertArrayValueToList takes the array branch and each row is
+                // serialized by serializeTupleData's array branch, producing the same bytes as the
+                // List-shaped case above.
+                {"Nested(a Int32, b String)",
+                        new Object[][] {{1, "x"}, {2, "y"}}},
+
+                // A Nullable field in the MIDDLE of the nested tuple, with a trailing fixed-width
+                // Float64: a dropped null-marker byte misaligns the Float64 and is caught. The
+                // second row exercises the null branch of that field.
+                {"Nested(a Int32, b Nullable(String), c Float64)",
+                        Arrays.asList(Arrays.asList(7, "opt", 9.5d), Arrays.asList(7, null, 8.5d))},
+
+                // An empty Nested serializes as a zero-length array.
+                {"Nested(a Int32, b String)", Arrays.asList()},
+        };
+    }
+
     // Normalizes Tuple (Object[]) and Array (ArrayValue / List) results to nested Lists so
     // round-tripped values compare structurally regardless of the container representation the
     // reader returns.

client-v2/src/test/java/com/clickhouse/client/datatypes/RowBinaryFormatWriterTest.java

@@ -534,6 +534,27 @@ public void writeNestedTests() throws Exception {
         writeTest(tableName, tableCreate, rows);
     }
 
+    @Test (groups = { "integration" })
+    public void writeNestedTypeTests() throws Exception {
+        String tableName = "rowBinaryFormatWriterTest_writeNestedTypeTests_" + UUID.randomUUID().toString().replace('-', '_');
+        // flatten_nested = 0 keeps the column typed as Nested(...) in the schema instead of
+        // expanding it into parallel Array(...) sub-columns; the un-flattened Nested type is the
+        // one that has to be serialized as Array(Tuple(...)).
+        String tableCreate = "CREATE TABLE \"" + tableName + "\" " +
+                " (id Int32, " +
+                "  n Nested(a UInt32, b Nullable(String)) " +
+                "  ) Engine = MergeTree ORDER BY id SETTINGS flatten_nested = 0";
+
+        List<Object> nested = Arrays.asList(Arrays.asList(10L, "x"), Arrays.asList(20L, null));
+        Field[][] rows = new Field[][] {{
+                    new Field("id", 1), //Row ID
+                    new Field("n", nested).set(nested) //Nested
+                }
+        };
+
+        writeTest(tableName, tableCreate, rows);
+    }
+
     @Test (groups = { "integration" })
     public void writeNullableTests() throws Exception {
         String tableName = "rowBinaryFormatWriterTest_writeNullableTests_" + UUID.randomUUID().toString().replace('-', '_');