Merge remote-tracking branch 'origin/main' into polyglot/client-v2-bfloat16

# Conflicts:
#	client-v2/src/test/java/com/clickhouse/client/api/data_formats/internal/SerializerUtilsPrimitiveSerializationTests.java

Author: polyglotAI-bot

CHANGELOG.md

@@ -12,6 +12,15 @@
 
 ### Bug Fixes 
 
+- **[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
+  non-matching boxed numeric type was supplied through the `Object`-typed insert surface — for example a
+  `Double` (the natural type of a Java literal like `1.5`) for a `Float32` column, or a `Float` for a
+  `Float64` column. The `RowBinary` serializer now narrows any `Number` (and, like the `Int*` columns,
+  a `String`/`Boolean`) through `Number#floatValue()`/`Number#doubleValue()`, so the float columns accept
+  the same value types the integer columns already did. (https://github.com/ClickHouse/clickhouse-java/issues/2930)
+
 - **[client-v2]** Fixed POJO insert error classification so transport write failures such as java.net.SocketException:
   Broken pipe (Write failed) are now surfaced as transfer/network errors instead of being wrapped as
   DataSerializationException. This only changes the exception type reported for request-body transport failures during

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

@@ -623,8 +623,8 @@ public ArrayValue readArray(ClickHouseColumn column) throws IOException {
         ArrayValue array;
         ClickHouseColumn itemTypeColumn = column.getNestedColumns().get(0);
         if (len == 0) {
-            Class<?> itemClass = itemTypeColumn.getDataType().getPrimitiveClass();
-            array = new ArrayValue(itemClass == null ? Object.class : itemClass, 0);
+            Class<?> itemClass = resolveArrayItemClass(itemTypeColumn);
+            array = new ArrayValue(itemClass, 0);
         } else if (column.getArrayNestedLevel() == 1) {
             array = readArrayItem(itemTypeColumn, len);
         } else {
@@ -639,8 +639,13 @@ public ArrayValue readArray(ClickHouseColumn column) throws IOException {
 
     public ArrayValue readArrayItem(ClickHouseColumn itemTypeColumn, int len) throws IOException {
         ArrayValue array;
-        if (itemTypeColumn.isNullable()
-                || itemTypeColumn.getDataType() == ClickHouseDataType.Variant
+        if (itemTypeColumn.isNullable()) {
+            Class<?> itemClass = resolveArrayItemClass(itemTypeColumn);
+            array = new ArrayValue(itemClass, len);
+            for (int i = 0; i < len; i++) {
+                array.set(i, readValue(itemTypeColumn));
+            }
+        } else if (itemTypeColumn.getDataType() == ClickHouseDataType.Variant
                 || itemTypeColumn.getDataType() == ClickHouseDataType.Dynamic
                 || itemTypeColumn.getDataType() == ClickHouseDataType.Geometry) {
             array = new ArrayValue(Object.class, len);
@@ -681,6 +686,64 @@ public ArrayValue readArrayItem(ClickHouseColumn itemTypeColumn, int len) throws
         return array;
     }
 
+    /**
+     * Resolves the Java class that {@link #readValue} actually returns for a given column
+     * so that it can be used as the component type of an array.
+     *
+     * <p>For unsigned integer types, {@code readValue} widens the value (e.g. UInt8 → Short,
+     * UInt32 → Long), so we use {@link ClickHouseDataType#getWiderObjectClass()} or 
+     * {@link ClickHouseDataType#getWiderPrimitiveClass()} which mirrors that widening.
+     * For Enum types, {@code readValue} returns {@link EnumValue} rather than the
+     * declared {@code String.class}. All other types use {@link ClickHouseDataType#getObjectClass()}
+     * or {@link ClickHouseDataType#getPrimitiveClass()}.
+     *
+     * @param itemTypeColumn the element column of the array
+     * @return the Java class to use as the array component type; never {@code null}
+     */
+    private static Class<?> resolveArrayItemClass(ClickHouseColumn itemTypeColumn) {
+        ClickHouseDataType dataType = itemTypeColumn.getDataType();
+        if (itemTypeColumn.isNullable()) {
+            switch (dataType) {
+                case UInt8:
+                case UInt16:
+                case UInt32:
+                case UInt64:
+                    return dataType.getWiderObjectClass();
+                case Enum8:
+                case Enum16:
+                    return EnumValue.class;
+                default:
+                    Class<?> cls = dataType.getObjectClass();
+                    return cls == null ? Object.class : cls;
+            }
+        } else {
+            switch (dataType) {
+                case UInt8:
+                case UInt16:
+                case UInt32:
+                case UInt64:
+                    return dataType.getWiderPrimitiveClass();
+                case Enum8:
+                case Enum16:
+                    return EnumValue.class;
+                case Variant:
+                case Dynamic:
+                case Geometry:
+                    return Object.class;
+                case Array:
+                    return ArrayValue.class;
+                case Tuple:
+                case Nested:
+                    return Object[].class;
+                case Map:
+                    return Map.class;
+                default:
+                    Class<?> cls = dataType.getPrimitiveClass();
+                    return cls == null ? Object.class : cls;
+            }
+        }
+    }
+
     public void skipValue(ClickHouseColumn column) throws IOException {
         readValue(column, null);
     }

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

@@ -558,10 +558,10 @@ private static void serializePrimitiveData(OutputStream stream, Object value, Cl
                 BinaryStreamUtils.writeBFloat16(stream, (float) value);
                 break;
             case Float32:
-                BinaryStreamUtils.writeFloat32(stream, (float) value);
+                BinaryStreamUtils.writeFloat32(stream, NumberConverter.toFloat(value));
                 break;
             case Float64:
-                BinaryStreamUtils.writeFloat64(stream, (double) value);
+                BinaryStreamUtils.writeFloat64(stream, NumberConverter.toDouble(value));
                 break;
             case Decimal:
             case Decimal32:

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

@@ -1,6 +1,7 @@
 package com.clickhouse.client.api.data_formats.internal;
 
 import com.clickhouse.data.ClickHouseColumn;
+import com.clickhouse.data.format.BinaryStreamUtils;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -206,24 +207,102 @@ public void testReadNullVariantReturnsNull() throws Exception {
     }
 
     @Test
-    public void testReadVarIntReadsMaxInt() throws IOException {
-        Assert.assertEquals(readVarInt((byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x07),
-                Integer.MAX_VALUE);
+    public void testNullableArrayValueUsesBoxedComponentType() throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        BinaryStreamUtils.writeVarInt(baos, 2);
+        BinaryStreamUtils.writeNonNull(baos);
+        BinaryStreamUtils.writeFloat64(baos, 1.0);
+        BinaryStreamUtils.writeNonNull(baos);
+        BinaryStreamUtils.writeFloat64(baos, 2.0);
+
+        BinaryStreamReader reader = new BinaryStreamReader(
+                new ByteArrayInputStream(baos.toByteArray()),
+                TimeZone.getTimeZone("UTC"),
+                null,
+                new BinaryStreamReader.CachingByteBufferAllocator(),
+                false,
+                null);
+
+        BinaryStreamReader.ArrayValue array = (BinaryStreamReader.ArrayValue) reader.readValue(
+                ClickHouseColumn.of("v", "Array(Nullable(Float64))"));
+
+        Assert.assertEquals(array.getArray().getClass().getComponentType(), Double.class);
     }
 
     @Test
-    public void testReadVarIntRejectsOverflow() {
-        Assert.assertThrows(IOException.class,
-                () -> readVarInt((byte) 0x80, (byte) 0x80, (byte) 0x80, (byte) 0x80, (byte) 0x08));
+    public void testNullableUnsignedArrayUsesWidenedType() throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        BinaryStreamUtils.writeVarInt(baos, 2);
+        BinaryStreamUtils.writeNonNull(baos);
+        BinaryStreamUtils.writeUnsignedInt8(baos, 10);
+        BinaryStreamUtils.writeNonNull(baos);
+        BinaryStreamUtils.writeUnsignedInt8(baos, 20);
+
+        BinaryStreamReader reader = new BinaryStreamReader(
+                new ByteArrayInputStream(baos.toByteArray()),
+                TimeZone.getTimeZone("UTC"),
+                null,
+                new BinaryStreamReader.CachingByteBufferAllocator(),
+                false,
+                null);
+
+        BinaryStreamReader.ArrayValue array = (BinaryStreamReader.ArrayValue) reader.readValue(
+                ClickHouseColumn.of("v", "Array(Nullable(UInt8))"));
+
+        Assert.assertEquals(array.getArray().getClass().getComponentType(), Short.class);
     }
 
     @Test
-    public void testReadVarIntRejectsOverlongValue() {
-        Assert.assertThrows(IOException.class,
-                () -> readVarInt((byte) 0x80, (byte) 0x80, (byte) 0x80, (byte) 0x80, (byte) 0x80, (byte) 0x01));
+    public void testNullableEnumArrayUsesEnumValueType() throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        BinaryStreamUtils.writeVarInt(baos, 2);
+        BinaryStreamUtils.writeNonNull(baos);
+        baos.write(1); // enum ordinal for 'a'
+        BinaryStreamUtils.writeNonNull(baos);
+        baos.write(2); // enum ordinal for 'b'
+
+        BinaryStreamReader reader = new BinaryStreamReader(
+                new ByteArrayInputStream(baos.toByteArray()),
+                TimeZone.getTimeZone("UTC"),
+                null,
+                new BinaryStreamReader.CachingByteBufferAllocator(),
+                false,
+                null);
+
+        BinaryStreamReader.ArrayValue array = (BinaryStreamReader.ArrayValue) reader.readValue(
+                ClickHouseColumn.of("v", "Array(Nullable(Enum8('a'=1,'b'=2)))"));
+
+        Assert.assertEquals(array.getArray().getClass().getComponentType(),
+                BinaryStreamReader.EnumValue.class);
+    }
+
+    @Test
+    public void testEmptyArrayTypes() throws Exception {
+        assertEmptyArrayComponentType("Array(UInt8)", short.class);
+        assertEmptyArrayComponentType("Array(Nullable(UInt8))", Short.class);
+        assertEmptyArrayComponentType("Array(String)", String.class);
+        assertEmptyArrayComponentType("Array(Nullable(String))", String.class);
+        assertEmptyArrayComponentType("Array(Enum8('a'=1))", BinaryStreamReader.EnumValue.class);
+        assertEmptyArrayComponentType("Array(Nullable(Enum8('a'=1)))", BinaryStreamReader.EnumValue.class);
+        assertEmptyArrayComponentType("Array(Variant(Int32, String))", Object.class);
+        assertEmptyArrayComponentType("Array(Array(String))", BinaryStreamReader.ArrayValue.class);
     }
 
-    private static int readVarInt(byte... bytes) throws IOException {
-        return BinaryStreamReader.readVarInt(new ByteArrayInputStream(bytes));
+    private void assertEmptyArrayComponentType(String columnType, Class<?> expectedComponentType) throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        BinaryStreamUtils.writeVarInt(baos, 0); 
+
+        BinaryStreamReader reader = new BinaryStreamReader(
+                new ByteArrayInputStream(baos.toByteArray()),
+                TimeZone.getTimeZone("UTC"),
+                null,
+                new BinaryStreamReader.CachingByteBufferAllocator(),
+                false,
+                null);
+
+        BinaryStreamReader.ArrayValue array = (BinaryStreamReader.ArrayValue) reader.readValue(
+                ClickHouseColumn.of("v", columnType));
+
+        Assert.assertEquals(array.getArray().getClass().getComponentType(), expectedComponentType, "Failed for " + columnType);
     }
 }

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

@@ -12,6 +12,7 @@
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.TimeZone;
 
 public class SerializerUtilsPrimitiveSerializationTests {
@@ -46,6 +47,70 @@ public void testSerializeDecimalTargetFromGenericNumberValue() throws IOExceptio
         Assert.assertEquals(reader.getBigDecimal("value"), new BigDecimal("987654.321"));
     }
 
+    @Test(dataProvider = "floatColumnValues")
+    public void testSerializeFloatColumnFromVariousNumberTypes(String type, Object value, double expected)
+            throws IOException {
+        RowBinaryWithNamesAndTypesFormatReader reader = serializeSingleValue(type, value);
+
+        reader.next();
+
+        Assert.assertEquals(reader.getDouble("value"), expected, 0.0);
+    }
+
+    @DataProvider(name = "floatColumnValues")
+    private Object[][] floatColumnValues() {
+        return new Object[][] {
+                // A Double supplied for a Float32 column (and a Float for a Float64 column) used to
+                // throw ClassCastException; any Number now narrows through Number#floatValue()/
+                // doubleValue(), matching how the Int* branches accept any Number.
+                {"Float32", 1.5d, 1.5},
+                {"Float32", -2.5d, -2.5},
+                {"Float64", 1.5f, 1.5},
+                {"Float64", -2.5f, -2.5},
+
+                // Same-type value keeps working unchanged (these already passed before the fix).
+                {"Float32", 1.5f, 1.5},
+                {"Float64", 2.5d, 2.5},
+
+                // Other Number subtypes are accepted for both float widths.
+                {"Float32", 3, 3.0},
+                {"Float32", 7L, 7.0},
+                {"Float32", (short) 5, 5.0},
+                {"Float32", (byte) 2, 2.0},
+                {"Float32", BigInteger.valueOf(9), 9.0},
+                {"Float32", new BigDecimal("1.5"), 1.5},
+                {"Float32", new CustomNumber("2.5"), 2.5},
+                {"Float64", 3, 3.0},
+                {"Float64", 7L, 7.0},
+                {"Float64", (short) 5, 5.0},
+                {"Float64", (byte) 2, 2.0},
+                {"Float64", BigInteger.valueOf(9), 9.0},
+                {"Float64", new BigDecimal("1.25"), 1.25},
+                {"Float64", new CustomNumber("2.5"), 2.5},
+
+                // String and Boolean are accepted too, matching the other numeric column branches.
+                {"Float32", "1.5", 1.5},
+                {"Float32", true, 1.0},
+                {"Float32", false, 0.0},
+                {"Float64", "1.5", 1.5},
+                {"Float64", true, 1.0},
+                {"Float64", false, 0.0},
+
+                // Out-of-Float-range values (now reachable through the fix) narrow like a primitive
+                // cast: a Double beyond Float range becomes Float32 infinity rather than throwing.
+                {"Float32", Double.MAX_VALUE, Double.POSITIVE_INFINITY},
+                {"Float32", -Double.MAX_VALUE, Double.NEGATIVE_INFINITY},
+        };
+    }
+
+    @Test
+    public void testSerializeFloatColumnRejectsUnsupportedValue() {
+        Assert.assertThrows(IllegalArgumentException.class,
+                () -> serializeSingleValue("Float32", new Object()));
+        Assert.assertThrows(IllegalArgumentException.class,
+                () -> serializeSingleValue("Float64", new Object()));
+    }
+
     @DataProvider(name = "bFloat16Values")
     public static Object[][] bFloat16Values() {
         // input float, expected float after a BFloat16 round-trip. BFloat16 keeps the high