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,