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

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


The following commit(s) were added to refs/heads/master by this push:
     new 754f8554da3 IGNITE-29157 SQL Calcite: Convert nested SQL values to 
external Java types in query results (#13698)
754f8554da3 is described below

commit 754f8554da379f6b0305305d258b4a0d5bc61f00
Author: Vladislav Pyatkov <[email protected]>
AuthorDate: Thu Oct 22 17:57:35 2026 +0300

    IGNITE-29157 SQL Calcite: Convert nested SQL values to external Java types 
in query results (#13698)
---
 .../processors/query/calcite/util/TypeUtils.java   | 105 ++++++-
 .../integration/MemoryQuotasIntegrationTest.java   |  10 +-
 .../NestedResultTypesIntegrationTest.java          | 328 +++++++++++++++++++++
 .../ignite/testsuites/IntegrationTestSuite.java    |   2 +
 4 files changed, 431 insertions(+), 14 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 b1f856966cb..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
@@ -33,8 +33,10 @@ import java.util.Arrays;
 import java.util.Calendar;
 import java.util.GregorianCalendar;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Set;
 import java.util.TimeZone;
 import java.util.UUID;
@@ -242,13 +244,45 @@ public class TypeUtils {
 
         for (int i = 0; i < sqlType.getFieldCount(); i++) {
             List<String> origin = origins == null ? null : origins.get(i);
-            b.add(fields.get(i).getName(), typeFactory.createType(
-                getResultClass(typeFactory, schema, fields.get(i).getType(), 
origin)));
+
+            b.add(fields.get(i).getName(), resultFieldType(typeFactory, 
schema, fields.get(i).getType(), origin));
         }
 
         return b.build();
     }
 
+    /** Preserves ROW, ARRAY and MAP types and resolves the external Java type 
of each leaf. */
+    private static RelDataType resultFieldType(
+        IgniteTypeFactory typeFactory,
+        RelOptSchema schema,
+        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));
+
+        RelDataType resultType;
+
+        if (type.isStruct())
+            resultType = getResultType(typeFactory, schema, type, null);
+        else if (type.getSqlTypeName() == SqlTypeName.ARRAY) {
+            RelDataType componentType = resultFieldType(typeFactory, schema, 
type.getComponentType(), null);
+
+            resultType = typeFactory.createArrayType(componentType, -1);
+        }
+        else if (type.getSqlTypeName() == SqlTypeName.MAP) {
+            resultType = typeFactory.createMapType(
+                resultFieldType(typeFactory, schema, type.getKeyType(), null),
+                resultFieldType(typeFactory, schema, type.getValueType(), 
null));
+        }
+        else
+            return typeFactory.createType(getResultClass(typeFactory, schema, 
type, origin));
+
+        return typeFactory.createTypeWithNullability(resultType, 
type.isNullable());
+    }
+
     /**
      * @param schema Schema.
      * @param type Logical column type.
@@ -299,7 +333,7 @@ public class TypeUtils {
     public static <Row> Function<Row, Row> 
resultTypeConverter(ExecutionContext<Row> ectx, RelDataType resultType) {
         assert resultType.isStruct();
 
-        if (hasConvertableFields(resultType)) {
+        if (needsResultConversion(resultType)) {
             RowHandler<Row> hnd = ectx.rowHandler();
             List<RelDataType> types = RelOptUtil.getFieldTypeList(resultType);
             RowHandler.RowFactory<Row> factory = 
hnd.factory(ectx.getTypeFactory(), types);
@@ -319,10 +353,53 @@ public class TypeUtils {
 
     /** */
     private static Function<Object, Object> fieldConverter(ExecutionContext<?> 
ectx, RelDataType fieldType) {
-        Type storageType = ectx.getTypeFactory().getJavaClass(fieldType);
+        // TODO https://issues.apache.org/jira/browse/IGNITE-15551 Add 
recursive conversion of MULTISET elements.
+        if (!needsResultConversion(fieldType))
+            return Function.identity();
+
+        if (fieldType instanceof RelDataTypeFactoryImpl.JavaType) {
+            Type storageType = ectx.getTypeFactory().getJavaClass(fieldType);
 
-        if (isConvertableType(storageType))
             return v -> fromInternal(ectx, v, storageType);
+        }
+
+        if (fieldType.isStruct()) {
+            List<Function<Object, Object>> converters = 
transform(fieldType.getFieldList(),
+                f -> fieldConverter(ectx, f.getType()));
+            return v -> {
+                if (v == null)
+                    return null;
+
+                Object[] row = ((Object[])v).clone();
+
+                for (int i = 0; i < converters.size(); i++)
+                    row[i] = converters.get(i).apply(row[i]);
+
+                return row;
+            };
+        }
+
+        if (fieldType.getSqlTypeName() == SqlTypeName.ARRAY) {
+            Function<Object, Object> elementConverter = fieldConverter(ectx, 
fieldType.getComponentType());
+
+            return v -> v == null ? null : transform((List<?>)v, 
elementConverter::apply);
+        }
+
+        if (fieldType.getSqlTypeName() == SqlTypeName.MAP) {
+            Function<Object, Object> keyConverter = fieldConverter(ectx, 
fieldType.getKeyType());
+            Function<Object, Object> valConverter = fieldConverter(ectx, 
fieldType.getValueType());
+
+            return v -> {
+                if (v == null)
+                    return null;
+
+                Map<Object, Object> map = new LinkedHashMap<>();
+
+                ((Map<?, ?>)v).forEach((key, val) -> 
map.put(keyConverter.apply(key), valConverter.apply(val)));
+
+                return map;
+            };
+        }
 
         return Function.identity();
     }
@@ -338,10 +415,20 @@ public class TypeUtils {
                     && 
isConvertableType(((RelDataTypeFactoryImpl.JavaType)type).getJavaClass());
     }
 
-    /** */
-    private static boolean hasConvertableFields(RelDataType resultType) {
-        return RelOptUtil.getFieldTypeList(resultType).stream()
-            .anyMatch(TypeUtils::isConvertableType);
+    /** 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);
+
+        if (type.isStruct())
+            return type.getFieldList().stream().anyMatch(f -> 
needsResultConversion(f.getType()));
+
+        if (type.getSqlTypeName() == SqlTypeName.ARRAY)
+            return needsResultConversion(type.getComponentType());
+
+        return type.getSqlTypeName() == SqlTypeName.MAP
+            && (needsResultConversion(type.getKeyType()) || 
needsResultConversion(type.getValueType()));
     }
 
     /** */
diff --git 
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/MemoryQuotasIntegrationTest.java
 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/MemoryQuotasIntegrationTest.java
index b0b670e7c4b..b95cfe0e7b1 100644
--- 
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/MemoryQuotasIntegrationTest.java
+++ 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/MemoryQuotasIntegrationTest.java
@@ -462,7 +462,7 @@ public class MemoryQuotasIntegrationTest extends 
AbstractBasicIntegrationTest {
             .resultSize(800)
             .check();
 
-        // getAll + collect for 1000 rows.
+        // getAll for 1000 rows.
         assertThrows("SELECT id, b FROM tbl",
             IgniteSQLException.class, "Query quota exceeded");
 
@@ -471,14 +471,14 @@ public class MemoryQuotasIntegrationTest extends 
AbstractBasicIntegrationTest {
             .resultSize(1)
             .check();
 
-        // getAll + collect for 400 rows.
-        assertQuery("SELECT ARRAY(SELECT b FROM tbl WHERE id < 400)")
+        // getAll + collect for 800 rows.
+        assertQuery("SELECT ARRAY(SELECT b FROM tbl WHERE id < 800)")
             .withRowsIterator(false)
             .resultSize(1)
             .check();
 
-        // getAll + collect for 800 rows.
-        assertThrows("SELECT ARRAY(SELECT b FROM tbl WHERE id < 800)",
+        // getAll accounts for both converted arrays, exceeding the quota.
+        assertThrows("SELECT arr, arr FROM (SELECT ARRAY(SELECT b FROM tbl 
WHERE id < 800) AS arr)",
             IgniteSQLException.class, "Query quota exceeded");
 
         // getAll + sort for 800 rows (sort node release memory after passing 
rows to iterator).
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
new file mode 100644
index 00000000000..502abb92999
--- /dev/null
+++ 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/NestedResultTypesIntegrationTest.java
@@ -0,0 +1,328 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.processors.query.calcite.integration;
+
+import java.sql.Date;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.time.Duration;
+import java.time.Period;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+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. */
+    private static Stream<Arguments> values() {
+        return Stream.of(
+            Arguments.of("DATE '2026-01-01'", Date.valueOf("2026-01-01")),
+            Arguments.of("TIME '12:34:56'", Time.valueOf("12:34:56")),
+            Arguments.of("TIMESTAMP '2026-01-01 12:34:56'", 
Timestamp.valueOf("2026-01-01 12:34:56")),
+            Arguments.of("INTERVAL '1' DAY", Duration.ofDays(1)),
+            Arguments.of("INTERVAL '1-2' YEAR TO MONTH", Period.of(1, 2, 0)),
+            Arguments.of("X'0102'", new byte[] {1, 2})
+        );
+    }
+
+    /** Wrapping the same value in ARRAY must not expose its internal 
representation. */
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("values")
+    public void testArrayElement(String expr, Object expected) {
+        String qry = "SELECT ARRAY[" + expr + ']';
+
+        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. */
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("values")
+    public void testArrayOfRows(String expr, Object expected) {
+        String qry = "SELECT ARRAY[ROW(" + expr + ", 42)]";
+
+        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(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)]";
+
+        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(2, row.length);
+                assertEquals(42, row[1]);
+                assertNull(row[0]);
+            })
+            .check();
+    }
+
+    /** The constructor's ROW value is a single result column containing two 
fields. */
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("values")
+    public void testRowField(String expr, Object expected) {
+        String qry = "SELECT ROW(" + expr + ", 42)";
+
+        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. */
+    @Test
+    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')";
+
+        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. */
+    @Test
+    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')]";
+
+        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. */
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("values")
+    public void testMapValue(String expr, Object expected) {
+        String qry = "SELECT MAP['value', " + expr + ']';
+
+        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. */
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("values")
+    public void testMapKey(String expr, Object expected) {
+        String qry = "SELECT MAP[" + expr + ", 42]";
+
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                Map<?, ?> map = assertInstanceOf(Map.class, singleValue(rows), 
qry);
+
+                assertEquals(1, map.size());
+
+                Map.Entry<?, ?> entry = map.entrySet().iterator().next();
+
+                assertExternalValue(expected, entry.getKey(), qry);
+                assertEquals(42, entry.getValue());
+            })
+            .check();
+    }
+
+    /** Converts keys and values together and preserves entries with NULL 
values. */
+    @Test
+    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)]";
+
+        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. */
+    @Test
+    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))]";
+
+        assertQuery(qry)
+            .withResultChecker(rows -> {
+                Map<?, ?> map = assertInstanceOf(Map.class, singleValue(rows), 
qry);
+
+                assertEquals(1, map.size());
+
+                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);
+
+                List<?> arr = assertInstanceOf(List.class, row[1], qry);
+
+                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)]";
+
+        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(2, row.length);
+                assertEquals(42, row[1]);
+
+                Map<?, ?> map = assertInstanceOf(Map.class, row[0], qry);
+
+                assertEquals(1, map.size());
+                assertExternalValue(Date.valueOf("2026-01-01"), 
map.get("value"), qry);
+            })
+            .check();
+    }
+
+    /** 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());
+
+        return rows.get(0).get(0);
+    }
+
+    /** Checks both Java type and value, including binary content. */
+    private static void assertExternalValue(Object expected, Object actual, 
String qry) {
+        assertInstanceOf(expected.getClass(), actual, qry + "; actual value: " 
+ actual);
+
+        if (expected instanceof byte[])
+            assertArrayEquals((byte[])expected, (byte[])actual, qry);
+        else
+            assertEquals(qry, expected, actual);
+    }
+}
diff --git 
a/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
 
b/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
index 39f01f6db55..118b68988ba 100644
--- 
a/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
+++ 
b/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
@@ -59,6 +59,7 @@ import 
org.apache.ignite.internal.processors.query.calcite.integration.LocalQuer
 import 
org.apache.ignite.internal.processors.query.calcite.integration.MemoryQuotasIntegrationTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.MetadataIntegrationTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.MultiDcQueryMappingTest;
+import 
org.apache.ignite.internal.processors.query.calcite.integration.NestedResultTypesIntegrationTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.OperatorsExtensionIntegrationTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.PartitionPruneTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.PartitionsReservationIntegrationTest;
@@ -130,6 +131,7 @@ import org.junit.platform.suite.api.Suite;
     StdSqlOperatorsTest.class,
     TableDmlIntegrationTest.class,
     DataTypesTest.class,
+    NestedResultTypesIntegrationTest.class,
     IndexSpoolIntegrationTest.class,
     HashSpoolIntegrationTest.class,
     IndexScanlIntegrationTest.class,

Reply via email to