This is an automated email from the ASF dual-hosted git repository.

vldpyatkov pushed a commit to branch ignite-29157
in repository https://gitbox.apache.org/repos/asf/ignite.git

commit 481fe344ec523e022aaa0a7dbe656f9e64dcbe0c
Author: Vladislav Pyatkov <[email protected]>
AuthorDate: Wed Oct 21 17:37:40 2026 +0300

    Fixed after review form @tkalkirill
---
 .../processors/query/calcite/util/TypeUtils.java   |   3 +
 .../NestedResultTypesIntegrationTest.java          | 254 ++++++++++++++-------
 2 files changed, 173 insertions(+), 84 deletions(-)

diff --git 
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/util/TypeUtils.java
 
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/util/TypeUtils.java
index 2d9a313fdb9..5383556de7b 100644
--- 
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/util/TypeUtils.java
+++ 
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/util/TypeUtils.java
@@ -258,6 +258,7 @@ public class TypeUtils {
         RelDataType type,
         @Nullable List<String> origin
     ) {
+        // TODO https://issues.apache.org/jira/browse/IGNITE-15551 Preserve 
MULTISET types and resolve their element types.
         // Java types, including byte[], are values rather than SQL containers.
         if (type instanceof RelDataTypeFactoryImpl.JavaType)
             return typeFactory.createType(getResultClass(typeFactory, schema, 
type, origin));
@@ -352,6 +353,7 @@ public class TypeUtils {
 
     /** */
     private static Function<Object, Object> fieldConverter(ExecutionContext<?> 
ectx, RelDataType fieldType) {
+        // TODO https://issues.apache.org/jira/browse/IGNITE-15551 Add 
recursive conversion of MULTISET elements.
         if (!needsResultConversion(fieldType))
             return Function.identity();
 
@@ -415,6 +417,7 @@ public class TypeUtils {
 
     /** Checks declared types during converter construction, without 
inspecting result values. */
     private static boolean needsResultConversion(RelDataType type) {
+        // TODO https://issues.apache.org/jira/browse/IGNITE-15551 Check 
MULTISET element types for required conversion.
         if (type instanceof RelDataTypeFactoryImpl.JavaType)
             return isConvertableType(type);
 
diff --git 
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/NestedResultTypesIntegrationTest.java
 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/NestedResultTypesIntegrationTest.java
index 70d8aaf8e40..502abb92999 100644
--- 
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/NestedResultTypesIntegrationTest.java
+++ 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/NestedResultTypesIntegrationTest.java
@@ -25,12 +25,15 @@ import java.time.Period;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import static 
org.apache.ignite.internal.processors.query.calcite.exec.rel.AbstractNode.IN_BUFFER_SIZE;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
 /** Checks external Java values in nested ROW, ARRAY and MAP results. */
 public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTest {
     /** SQL literals and their expected external values, independent of the 
execution representation. */
@@ -50,10 +53,15 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     @MethodSource("values")
     public void testArrayElement(String expr, Object expected) {
         String qry = "SELECT ARRAY[" + expr + ']';
-        List<?> arr = Assertions.assertInstanceOf(List.class, value(qry), qry);
 
-        assertEquals(1, arr.size());
-        assertExternalValue(expected, arr.get(0), qry);
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                List<?> arr = assertInstanceOf(List.class, singleValue(rows), 
qry);
+
+                assertEquals(1, arr.size());
+                assertExternalValue(expected, arr.get(0), qry);
+            })
+            .check();
     }
 
     /** Conversion must descend through multiple levels, as required by 
ARRAY-of-ROW paths. */
@@ -61,30 +69,40 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     @MethodSource("values")
     public void testArrayOfRows(String expr, Object expected) {
         String qry = "SELECT ARRAY[ROW(" + expr + ", 42)]";
-        List<?> arr = Assertions.assertInstanceOf(List.class, value(qry), qry);
 
-        assertEquals(1, arr.size());
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                List<?> arr = assertInstanceOf(List.class, singleValue(rows), 
qry);
 
-        Object[] row = Assertions.assertInstanceOf(Object[].class, arr.get(0), 
qry);
+                assertEquals(1, arr.size());
 
-        assertEquals(2, row.length);
-        assertEquals(42, row[1]);
-        assertExternalValue(expected, row[0], qry);
+                Object[] row = assertInstanceOf(Object[].class, arr.get(0), 
qry);
+
+                assertEquals(2, row.length);
+                assertEquals(42, row[1]);
+                assertExternalValue(expected, row[0], qry);
+            })
+            .check();
     }
 
     /** NULL fields in an ARRAY-of-ROW result must remain NULL after 
conversion. */
     @Test
     public void testArrayOfRowsWithNullField() {
         String qry = "SELECT ARRAY[ROW(CAST(NULL AS DATE), 42)]";
-        List<?> arr = Assertions.assertInstanceOf(List.class, value(qry), qry);
 
-        assertEquals(1, arr.size());
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                List<?> arr = assertInstanceOf(List.class, singleValue(rows), 
qry);
+
+                assertEquals(1, arr.size());
 
-        Object[] row = Assertions.assertInstanceOf(Object[].class, arr.get(0), 
qry);
+                Object[] row = assertInstanceOf(Object[].class, arr.get(0), 
qry);
 
-        assertEquals(2, row.length);
-        assertEquals(42, row[1]);
-        assertNull(row[0]);
+                assertEquals(2, row.length);
+                assertEquals(42, row[1]);
+                assertNull(row[0]);
+            })
+            .check();
     }
 
     /** The constructor's ROW value is a single result column containing two 
fields. */
@@ -92,11 +110,16 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     @MethodSource("values")
     public void testRowField(String expr, Object expected) {
         String qry = "SELECT ROW(" + expr + ", 42)";
-        Object[] row = Assertions.assertInstanceOf(Object[].class, value(qry), 
qry);
 
-        assertEquals(2, row.length);
-        assertEquals(42, row[1]);
-        assertExternalValue(expected, row[0], qry);
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                Object[] row = assertInstanceOf(Object[].class, 
singleValue(rows), qry);
+
+                assertEquals(2, row.length);
+                assertEquals(42, row[1]);
+                assertExternalValue(expected, row[0], qry);
+            })
+            .check();
     }
 
     /** Each field is converted according to its own type, preserving order 
and NULL values. */
@@ -104,18 +127,23 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     public void testRowWithDifferentFieldTypes() {
         String qry = "SELECT ROW(DATE '2026-01-01', 42, TIME '12:34:56', 
'text', CAST(NULL AS DATE), "
             + "TIMESTAMP '2026-01-01 12:34:56', INTERVAL '1' DAY, INTERVAL 
'1-2' YEAR TO MONTH, X'0102')";
-        Object[] row = Assertions.assertInstanceOf(Object[].class, value(qry), 
qry);
-
-        assertEquals(9, row.length);
-        assertExternalValue(Date.valueOf("2026-01-01"), row[0], qry);
-        assertExternalValue(42, row[1], qry);
-        assertExternalValue(Time.valueOf("12:34:56"), row[2], qry);
-        assertExternalValue("text", row[3], qry);
-        assertNull(row[4]);
-        assertExternalValue(Timestamp.valueOf("2026-01-01 12:34:56"), row[5], 
qry);
-        assertExternalValue(Duration.ofDays(1), row[6], qry);
-        assertExternalValue(Period.of(1, 2, 0), row[7], qry);
-        assertExternalValue(new byte[] {1, 2}, row[8], qry);
+
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                Object[] row = assertInstanceOf(Object[].class, 
singleValue(rows), qry);
+
+                assertEquals(9, row.length);
+                assertExternalValue(Date.valueOf("2026-01-01"), row[0], qry);
+                assertExternalValue(42, row[1], qry);
+                assertExternalValue(Time.valueOf("12:34:56"), row[2], qry);
+                assertExternalValue("text", row[3], qry);
+                assertNull(row[4]);
+                assertExternalValue(Timestamp.valueOf("2026-01-01 12:34:56"), 
row[5], qry);
+                assertExternalValue(Duration.ofDays(1), row[6], qry);
+                assertExternalValue(Period.of(1, 2, 0), row[7], qry);
+                assertExternalValue(new byte[] {1, 2}, row[8], qry);
+            })
+            .check();
     }
 
     /** Fields of different types are also converted when the ROW is inside an 
ARRAY. */
@@ -123,22 +151,27 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     public void testArrayOfRowsWithDifferentFieldTypes() {
         String qry = "SELECT ARRAY[ROW(DATE '2026-01-01', 42, TIME '12:34:56', 
'text', CAST(NULL AS DATE), "
             + "TIMESTAMP '2026-01-01 12:34:56', INTERVAL '1' DAY, INTERVAL 
'1-2' YEAR TO MONTH, X'0102')]";
-        List<?> arr = Assertions.assertInstanceOf(List.class, value(qry), qry);
-
-        assertEquals(1, arr.size());
-
-        Object[] row = Assertions.assertInstanceOf(Object[].class, arr.get(0), 
qry);
-
-        assertEquals(9, row.length);
-        assertExternalValue(Date.valueOf("2026-01-01"), row[0], qry);
-        assertExternalValue(42, row[1], qry);
-        assertExternalValue(Time.valueOf("12:34:56"), row[2], qry);
-        assertExternalValue("text", row[3], qry);
-        assertNull(row[4]);
-        assertExternalValue(Timestamp.valueOf("2026-01-01 12:34:56"), row[5], 
qry);
-        assertExternalValue(Duration.ofDays(1), row[6], qry);
-        assertExternalValue(Period.of(1, 2, 0), row[7], qry);
-        assertExternalValue(new byte[] {1, 2}, row[8], qry);
+
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                List<?> arr = assertInstanceOf(List.class, singleValue(rows), 
qry);
+
+                assertEquals(1, arr.size());
+
+                Object[] row = assertInstanceOf(Object[].class, arr.get(0), 
qry);
+
+                assertEquals(9, row.length);
+                assertExternalValue(Date.valueOf("2026-01-01"), row[0], qry);
+                assertExternalValue(42, row[1], qry);
+                assertExternalValue(Time.valueOf("12:34:56"), row[2], qry);
+                assertExternalValue("text", row[3], qry);
+                assertNull(row[4]);
+                assertExternalValue(Timestamp.valueOf("2026-01-01 12:34:56"), 
row[5], qry);
+                assertExternalValue(Duration.ofDays(1), row[6], qry);
+                assertExternalValue(Period.of(1, 2, 0), row[7], qry);
+                assertExternalValue(new byte[] {1, 2}, row[8], qry);
+            })
+            .check();
     }
 
     /** MAP values must use the same external types as other result values. */
@@ -146,10 +179,15 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     @MethodSource("values")
     public void testMapValue(String expr, Object expected) {
         String qry = "SELECT MAP['value', " + expr + ']';
-        Map<?, ?> map = Assertions.assertInstanceOf(Map.class, value(qry), 
qry);
 
-        assertEquals(1, map.size());
-        assertExternalValue(expected, map.get("value"), qry);
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                Map<?, ?> map = assertInstanceOf(Map.class, singleValue(rows), 
qry);
+
+                assertEquals(1, map.size());
+                assertExternalValue(expected, map.get("value"), qry);
+            })
+            .check();
     }
 
     /** MAP keys must also be converted, including binary keys compared by 
content. */
@@ -157,14 +195,19 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     @MethodSource("values")
     public void testMapKey(String expr, Object expected) {
         String qry = "SELECT MAP[" + expr + ", 42]";
-        Map<?, ?> map = Assertions.assertInstanceOf(Map.class, value(qry), 
qry);
 
-        assertEquals(1, map.size());
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                Map<?, ?> map = assertInstanceOf(Map.class, singleValue(rows), 
qry);
+
+                assertEquals(1, map.size());
 
-        Map.Entry<?, ?> entry = map.entrySet().iterator().next();
+                Map.Entry<?, ?> entry = map.entrySet().iterator().next();
 
-        assertExternalValue(expected, entry.getKey(), qry);
-        assertEquals(42, entry.getValue());
+                assertExternalValue(expected, entry.getKey(), qry);
+                assertEquals(42, entry.getValue());
+            })
+            .check();
     }
 
     /** Converts keys and values together and preserves entries with NULL 
values. */
@@ -172,12 +215,17 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     public void testMapWithDifferentKeyAndValueTypes() {
         String qry = "SELECT MAP[DATE '2026-01-01', TIMESTAMP '2026-01-01 
12:34:56', "
             + "DATE '2026-01-02', CAST(NULL AS TIMESTAMP)]";
-        Map<?, ?> map = Assertions.assertInstanceOf(Map.class, value(qry), 
qry);
 
-        assertEquals(2, map.size());
-        assertExternalValue(Timestamp.valueOf("2026-01-01 12:34:56"), 
map.get(Date.valueOf("2026-01-01")), qry);
-        assertTrue(map.containsKey(Date.valueOf("2026-01-02")));
-        assertNull(map.get(Date.valueOf("2026-01-02")));
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                Map<?, ?> map = assertInstanceOf(Map.class, singleValue(rows), 
qry);
+
+                assertEquals(2, map.size());
+                assertExternalValue(Timestamp.valueOf("2026-01-01 12:34:56"), 
map.get(Date.valueOf("2026-01-01")), qry);
+                assertTrue(map.containsKey(Date.valueOf("2026-01-02")));
+                assertNull(map.get(Date.valueOf("2026-01-02")));
+            })
+            .check();
     }
 
     /** Conversion descends from a MAP value into a ROW and its ARRAY field. */
@@ -185,45 +233,83 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
     public void testMapWithRowValue() {
         String qry = "SELECT MAP[DATE '2026-01-01', ROW(TIMESTAMP '2026-01-01 
12:34:56', "
             + "ARRAY[INTERVAL '1' DAY], CAST(NULL AS TIME))]";
-        Map<?, ?> map = Assertions.assertInstanceOf(Map.class, value(qry), 
qry);
 
-        assertEquals(1, map.size());
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                Map<?, ?> map = assertInstanceOf(Map.class, singleValue(rows), 
qry);
+
+                assertEquals(1, map.size());
 
-        Object[] row = Assertions.assertInstanceOf(Object[].class, 
map.get(Date.valueOf("2026-01-01")), qry);
+                Object[] row = assertInstanceOf(Object[].class, 
map.get(Date.valueOf("2026-01-01")), qry);
 
-        assertEquals(3, row.length);
-        assertExternalValue(Timestamp.valueOf("2026-01-01 12:34:56"), row[0], 
qry);
+                assertEquals(3, row.length);
+                assertExternalValue(Timestamp.valueOf("2026-01-01 12:34:56"), 
row[0], qry);
 
-        List<?> arr = Assertions.assertInstanceOf(List.class, row[1], qry);
+                List<?> arr = assertInstanceOf(List.class, row[1], qry);
 
-        assertEquals(1, arr.size());
-        assertExternalValue(Duration.ofDays(1), arr.get(0), qry);
-        assertNull(row[2]);
+                assertEquals(1, arr.size());
+                assertExternalValue(Duration.ofDays(1), arr.get(0), qry);
+                assertNull(row[2]);
+            })
+            .check();
     }
 
     /** A MAP nested in a CYCLE-like ARRAY-of-ROW result also requires 
conversion. */
     @Test
     public void testArrayOfRowsWithMapField() {
         String qry = "SELECT ARRAY[ROW(MAP['value', DATE '2026-01-01'], 42)]";
-        List<?> arr = Assertions.assertInstanceOf(List.class, value(qry), qry);
 
-        assertEquals(1, arr.size());
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                List<?> arr = assertInstanceOf(List.class, singleValue(rows), 
qry);
 
-        Object[] row = Assertions.assertInstanceOf(Object[].class, arr.get(0), 
qry);
+                assertEquals(1, arr.size());
 
-        assertEquals(2, row.length);
-        assertEquals(42, row[1]);
+                Object[] row = assertInstanceOf(Object[].class, arr.get(0), 
qry);
 
-        Map<?, ?> map = Assertions.assertInstanceOf(Map.class, row[0], qry);
+                assertEquals(2, row.length);
+                assertEquals(42, row[1]);
 
-        assertEquals(1, map.size());
-        assertExternalValue(Date.valueOf("2026-01-01"), map.get("value"), qry);
+                Map<?, ?> map = assertInstanceOf(Map.class, row[0], qry);
+
+                assertEquals(1, map.size());
+                assertExternalValue(Date.valueOf("2026-01-01"), 
map.get("value"), qry);
+            })
+            .check();
     }
 
-    /** Executes a one-row, one-column query without normalizing the returned 
value. */
-    private Object value(String qry) {
-        List<List<?>> rows = sql(qry);
+    /** Returning an ARRAY of ROWs must not change values still used by 
subsequent UNNEST iterations. */
+    @Test
+    public void testArrayOfRowsReusedByJoin() {
+        // Exceed the execution buffers so UNNEST continues after the first 
results have been converted.
+        int rowsCnt = 8 * IN_BUFFER_SIZE;
+        String qry = "SELECT a.arr, OCTET_LENGTH(u.bin) FROM 
TABLE(SYSTEM_RANGE(1, " + rowsCnt + ")) s "
+            + "CROSS JOIN (SELECT ARRAY_AGG(ROW(X'0102', x)) arr FROM 
TABLE(SYSTEM_RANGE(1, 1))) a "
+            + "CROSS JOIN UNNEST(a.arr) u(bin, id)";
+
+        assertQuery(grid(0), qry)
+            .resultSize(rowsCnt)
+            .withResultChecker(rows -> {
+                for (List<?> row : rows) {
+                    assertEquals(2, row.size());
+                    assertEquals(2, row.get(1));
+
+                    List<?> arr = assertInstanceOf(List.class, row.get(0), 
qry);
+
+                    assertEquals(1, arr.size());
+
+                    Object[] nestedRow = assertInstanceOf(Object[].class, 
arr.get(0), qry);
+
+                    assertEquals(2, nestedRow.length);
+                    assertExternalValue(new byte[] {1, 2}, nestedRow[0], qry);
+                    assertEquals(1L, nestedRow[1]);
+                }
+            })
+            .check();
+    }
 
+    /** Extracts the only result value without normalizing it. */
+    private static Object singleValue(List<List<?>> rows) {
         assertEquals(1, rows.size());
         assertEquals(1, rows.get(0).size());
 
@@ -232,11 +318,11 @@ public class NestedResultTypesIntegrationTest extends 
AbstractBasicIntegrationTe
 
     /** Checks both Java type and value, including binary content. */
     private static void assertExternalValue(Object expected, Object actual, 
String qry) {
-        Assertions.assertInstanceOf(expected.getClass(), actual, qry + "; 
actual value: " + actual);
+        assertInstanceOf(expected.getClass(), actual, qry + "; actual value: " 
+ actual);
 
         if (expected instanceof byte[])
-            Assertions.assertArrayEquals((byte[])expected, (byte[])actual, 
qry);
+            assertArrayEquals((byte[])expected, (byte[])actual, qry);
         else
-            Assertions.assertEquals(expected, actual, qry);
+            assertEquals(qry, expected, actual);
     }
 }

Reply via email to