covered getters by index

Author: chernser

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

@@ -351,7 +351,9 @@ private <T> T getPrimitiveArray(String colName, Class<?> componentType) {
      * may materialize numeric array elements as different boxed types
      * (e.g. {@code Integer}, {@code Long}, {@code Double}, {@code BigDecimal}),
      * so element-level conversion is necessary before populating a typed
-     * primitive array.
+     * primitive array. The {@code componentType} is always one of the eight
+     * Java primitives passed by {@link #getPrimitiveArray}; unsupported
+     * component types are rejected explicitly to keep the helper total.
      */
     private static Object coerceToComponent(Object value, Class<?> componentType) {
         if (componentType == byte.class) {
@@ -382,7 +384,7 @@ private static Object coerceToComponent(Object value, Class<?> componentType) {
             throw new IllegalArgumentException(
                     "Cannot convert " + value.getClass().getName() + " to boolean array element");
         }
-        return value;
+        throw new IllegalArgumentException("Unsupported component type: " + componentType.getName());
     }
 
     @Override

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

@@ -450,20 +450,33 @@ public void testArrayAccessors() throws Exception {
             Assert.assertNotNull(intList);
             Assert.assertEquals(intList.size(), 3);
 
+            // Each typed accessor is exercised by name first and then by 1-based
+            // column index so the index-based overloads are also covered against
+            // the inferred schema produced from the first row.
             Assert.assertEquals(reader.getIntArray("col_int_arr"), new int[] {1, 2, 3});
             Assert.assertEquals(reader.getIntArray(1), new int[] {1, 2, 3});
             Assert.assertEquals(reader.getLongArray("col_long_arr"), new long[] {10L, 20L, 30L});
             Assert.assertEquals(reader.getLongArray(2), new long[] {10L, 20L, 30L});
-            Assert.assertEquals(reader.getShortArray("col_short_arr"), new short[] {(short) 1, (short) 2});
+            Assert.assertEquals(reader.getShortArray("col_short_arr"),
+                    new short[] {(short) 1, (short) 2});
+            Assert.assertEquals(reader.getShortArray(3), new short[] {(short) 1, (short) 2});
             Assert.assertEquals(reader.getByteArray("col_byte_arr"), new byte[] {(byte) 7, (byte) 8});
-            Assert.assertEquals(reader.getDoubleArray("col_double_arr"), new double[] {1.5d, 2.5d}, 1e-9);
-            Assert.assertEquals(reader.getFloatArray("col_float_arr"), new float[] {1.0f, 2.0f}, 1e-6f);
-            Assert.assertEquals(reader.getStringArray("col_string_arr"), new String[] {"a", "b", "c"});
+            Assert.assertEquals(reader.getByteArray(4), new byte[] {(byte) 7, (byte) 8});
+            Assert.assertEquals(reader.getDoubleArray("col_double_arr"),
+                    new double[] {1.5d, 2.5d}, 1e-9);
+            Assert.assertEquals(reader.getDoubleArray(5), new double[] {1.5d, 2.5d}, 1e-9);
+            Assert.assertEquals(reader.getFloatArray("col_float_arr"),
+                    new float[] {1.0f, 2.0f}, 1e-6f);
+            Assert.assertEquals(reader.getFloatArray(6), new float[] {1.0f, 2.0f}, 1e-6f);
+            Assert.assertEquals(reader.getStringArray("col_string_arr"),
+                    new String[] {"a", "b", "c"});
+            Assert.assertEquals(reader.getStringArray(7), new String[] {"a", "b", "c"});
             Assert.assertEquals(reader.getBooleanArray("col_bool_arr"),
                     new boolean[] {true, false, true});
+            Assert.assertEquals(reader.getBooleanArray(8), new boolean[] {true, false, true});
 
-            Object[] objs = reader.getObjectArray("col_int_arr");
-            Assert.assertEquals(objs.length, 3);
+            Assert.assertEquals(reader.getObjectArray("col_int_arr").length, 3);
+            Assert.assertEquals(reader.getObjectArray(1).length, 3);
 
             // Non-array columns must surface a RuntimeException rather than
             // silently returning null or a malformed array.
@@ -482,6 +495,55 @@ public void testArrayAccessors() throws Exception {
         }
     }
 
+    /**
+     * Locks in the contract that a {@code null} element coming from the server
+     * (e.g. through {@code Array(Nullable(...))}) cannot be silently turned
+     * into a zero/false slot of a Java primitive array. The reader must throw
+     * a {@link RuntimeException} so callers don't lose the distinction between
+     * "missing value" and "actual zero".
+     */
+    @Test(groups = {"integration"})
+    public void testArrayAccessorsRejectNullElementsFromServer() throws Exception {
+        String sql = "SELECT "
+                + "[1, NULL, 3]::Array(Nullable(Int32)) AS col_int_arr, "
+                + "[true, NULL]::Array(Nullable(Bool)) AS col_bool_arr, "
+                + "['x', NULL, 'z']::Array(Nullable(String)) AS col_string_arr";
+
+        try (QueryResponse response =
+                     client.query(sql, newJsonEachRowSettingsForPrimitives()).get();
+             ClickHouseTextFormatReader reader = createReader(response)) {
+
+            Assert.assertNotNull(reader.next());
+
+            try {
+                reader.getIntArray("col_int_arr");
+                Assert.fail("Expected exception on null element in primitive array");
+            } catch (RuntimeException expected) {
+                // ok
+            }
+            try {
+                reader.getBooleanArray("col_bool_arr");
+                Assert.fail("Expected exception on null element in primitive array");
+            } catch (RuntimeException expected) {
+                // ok
+            }
+
+            // getStringArray and getObjectArray preserve nulls because the
+            // resulting array can hold null references.
+            Assert.assertEquals(reader.getStringArray("col_string_arr"),
+                    new String[] {"x", null, "z"});
+            Object[] objs = reader.getObjectArray("col_string_arr");
+            Assert.assertEquals(objs.length, 3);
+            Assert.assertNull(objs[1]);
+
+            // getList must surface the raw list with the null element intact.
+            List<?> intList = reader.getList("col_int_arr");
+            Assert.assertNotNull(intList);
+            Assert.assertEquals(intList.size(), 3);
+            Assert.assertNull(intList.get(1));
+        }
+    }
+
     // ------------------------------------------------------------------
     // Test case definitions for primitive types
     // ------------------------------------------------------------------

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

@@ -501,13 +501,63 @@ public void testArrayAccessorsReturnNullForNullValue() throws Exception {
         try (JSONEachRowFormatReader reader = new JSONEachRowFormatReader(
                 new StubJsonParser(Collections.singletonList(r)))) {
             reader.next();
+
+            // By name: every array accessor must propagate the null cleanly
+            // rather than throw NullPointerException or fabricate an empty array.
             Assert.assertNull(reader.getList("v"));
+            Assert.assertNull(reader.getByteArray("v"));
+            Assert.assertNull(reader.getShortArray("v"));
             Assert.assertNull(reader.getIntArray("v"));
             Assert.assertNull(reader.getLongArray("v"));
+            Assert.assertNull(reader.getFloatArray("v"));
             Assert.assertNull(reader.getDoubleArray("v"));
             Assert.assertNull(reader.getBooleanArray("v"));
             Assert.assertNull(reader.getStringArray("v"));
             Assert.assertNull(reader.getObjectArray("v"));
+
+            // By 1-based index: the same null-propagation guarantee must hold
+            // for the index-based overloads, which delegate to the name-based
+            // implementations through the inferred schema.
+            Assert.assertNull(reader.getList(1));
+            Assert.assertNull(reader.getByteArray(1));
+            Assert.assertNull(reader.getShortArray(1));
+            Assert.assertNull(reader.getIntArray(1));
+            Assert.assertNull(reader.getLongArray(1));
+            Assert.assertNull(reader.getFloatArray(1));
+            Assert.assertNull(reader.getDoubleArray(1));
+            Assert.assertNull(reader.getBooleanArray(1));
+            Assert.assertNull(reader.getStringArray(1));
+            Assert.assertNull(reader.getObjectArray(1));
+        }
+    }
+
+    @Test
+    public void testArrayAccessorsRejectNullElement() throws Exception {
+        // A null element in a JSON array cannot be stored into a Java
+        // primitive array slot, so getPrimitiveArray must surface this rather
+        // than substitute a zero/false value silently. The String and Object
+        // overloads are allowed to keep the null element.
+        try (JSONEachRowFormatReader reader = readerOf(row(
+                "ints", Arrays.asList(1, null, 3),
+                "bools", Arrays.asList(Boolean.TRUE, null),
+                "strs", Arrays.asList("a", null, "c"),
+                "objs", Arrays.asList("x", null)))) {
+            reader.next();
+
+            assertThrowsRuntime(() -> reader.getIntArray("ints"));
+            assertThrowsRuntime(() -> reader.getIntArray(1));
+            assertThrowsRuntime(() -> reader.getLongArray("ints"));
+            assertThrowsRuntime(() -> reader.getShortArray("ints"));
+            assertThrowsRuntime(() -> reader.getByteArray("ints"));
+            assertThrowsRuntime(() -> reader.getFloatArray("ints"));
+            assertThrowsRuntime(() -> reader.getDoubleArray("ints"));
+            assertThrowsRuntime(() -> reader.getBooleanArray("bools"));
+
+            // The non-primitive container accessors keep nulls.
+            Assert.assertEquals(reader.getStringArray("strs"), new String[] {"a", null, "c"});
+            Object[] objs = reader.getObjectArray("objs");
+            Assert.assertEquals(objs.length, 2);
+            Assert.assertNull(objs[1]);
         }
     }
 
@@ -538,6 +588,76 @@ public void testArrayAccessorsRejectNonArrayValues() throws Exception {
         }
     }
 
+    @Test
+    public void testArrayAccessorsByIndex() throws Exception {
+        // Mirrors testArrayAccessorsCoercePrimitiveElements but addresses every
+        // typed array accessor through its 1-based column index. This ensures
+        // the index-based overloads delegate correctly through the inferred
+        // schema, even for arrays where the schema only records "Array" without
+        // a specific element type.
+        try (JSONEachRowFormatReader reader = readerOf(row(
+                "ints", Arrays.asList(1, 2, 3),
+                "longs", Arrays.asList(10L, 20L, 30L),
+                "shorts", Arrays.asList((short) 4, (short) 5),
+                "bytes", Arrays.asList((byte) 6, (byte) 7),
+                "doubles", Arrays.asList(1.5d, 2.5d),
+                "floats", Arrays.asList(1.0f, 2.0f),
+                "bools", Arrays.asList(Boolean.TRUE, Boolean.FALSE),
+                "strs", Arrays.asList("a", "b")))) {
+            reader.next();
+
+            Assert.assertEquals(reader.getIntArray(1), new int[] {1, 2, 3});
+            Assert.assertEquals(reader.getLongArray(2), new long[] {10L, 20L, 30L});
+            Assert.assertEquals(reader.getShortArray(3), new short[] {(short) 4, (short) 5});
+            Assert.assertEquals(reader.getByteArray(4), new byte[] {(byte) 6, (byte) 7});
+            Assert.assertEquals(reader.getDoubleArray(5), new double[] {1.5d, 2.5d}, 1e-9);
+            Assert.assertEquals(reader.getFloatArray(6), new float[] {1.0f, 2.0f}, 1e-6f);
+            Assert.assertEquals(reader.getBooleanArray(7), new boolean[] {true, false});
+            Assert.assertEquals(reader.getStringArray(8), new String[] {"a", "b"});
+
+            // getList and getObjectArray by index, on the first column.
+            List<Integer> list = reader.getList(1);
+            Assert.assertEquals(list, Arrays.asList(1, 2, 3));
+            Object[] objs = reader.getObjectArray(1);
+            Assert.assertEquals(objs.length, 3);
+        }
+    }
+
+    @Test
+    public void testGetBooleanArrayFromNumericList() throws Exception {
+        // Exercises the Number branch in coerceToComponent for boolean[]: the
+        // reader treats 0 as false and any non-zero value as true, regardless
+        // of whether the parser materialized the element as Integer, Long, or
+        // BigDecimal.
+        try (JSONEachRowFormatReader reader = readerOf(row(
+                "as_int", Arrays.asList(0, 1, 2, -1),
+                "as_long", Arrays.asList(0L, 5L),
+                "as_big_decimal", Arrays.asList(BigDecimal.ZERO, new BigDecimal("3"))))) {
+            reader.next();
+
+            Assert.assertEquals(reader.getBooleanArray("as_int"),
+                    new boolean[] {false, true, true, true});
+            Assert.assertEquals(reader.getBooleanArray("as_long"),
+                    new boolean[] {false, true});
+            Assert.assertEquals(reader.getBooleanArray("as_big_decimal"),
+                    new boolean[] {false, true});
+        }
+    }
+
+    @Test
+    public void testGetBooleanArrayRejectsNonBooleanNonNumberElements() throws Exception {
+        // String elements cannot be coerced into boolean[] (we don't accept
+        // string-to-boolean parsing on the scalar getBoolean accessor either),
+        // so getBooleanArray must surface a RuntimeException sourced from the
+        // illegal-coerce branch in coerceToComponent.
+        try (JSONEachRowFormatReader reader = readerOf(row(
+                "v", Arrays.asList("true", "false")))) {
+            reader.next();
+            assertThrowsRuntime(() -> reader.getBooleanArray("v"));
+            assertThrowsRuntime(() -> reader.getBooleanArray(1));
+        }
+    }
+
     @Test
     public void testArrayAccessorsCoercePrimitiveElements() throws Exception {
         // Different parsers materialize numbers as different boxed types