Fix client-v2: accept any Number for Float32/Float64 insert values

Float32/Float64 columns threw ClassCastException when a value whose boxed
type did not match the column 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 narrowed with a direct `(float) value` / `(double) value` cast,
which is a narrowing reference conversion to Float/Double followed by
unboxing and fails for any other boxed numeric type.

Route the two branches through the shared NumberConverter.toFloat/toDouble
converters, matching the neighboring UInt/Decimal branches, so the float
columns accept any Number (and String/Boolean) exactly like the Int*
columns already do.

Fixes: #2930

Author: polyglotAI-bot

CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ### Bug Fixes 
 
+- **[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/SerializerUtils.java

@@ -555,10 +555,10 @@ private static void serializePrimitiveData(OutputStream stream, Object value, Cl
                 BinaryStreamUtils.writeUnsignedInt256(stream, NumberConverter.toBigInteger(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/SerializerUtilsPrimitiveSerializationTests.java

@@ -5,12 +5,14 @@
 import com.clickhouse.data.ClickHouseColumn;
 import com.clickhouse.data.format.BinaryStreamUtils;
 import org.testng.Assert;
+import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.TimeZone;
 
 public class SerializerUtilsPrimitiveSerializationTests {
@@ -45,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()));
+    }
+
     private RowBinaryWithNamesAndTypesFormatReader serializeSingleValue(String type, Object value)
             throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();