This is an automated email from the ASF dual-hosted git repository. tkalkirill pushed a commit to branch poc-support-multiset in repository https://gitbox.apache.org/repos/asf/ignite.git
commit 8f1a0e2147681fd29bd6f3a5448ae568c5f1d508 Author: Kirill Tkalenko <[email protected]> AuthorDate: Thu Oct 1 14:04:08 2026 +0300 POC support multiset --- .../query/calcite/exec/exp/RexImpTable.java | 43 ++-- .../query/calcite/exec/rel/CollectNode.java | 14 +- .../query/calcite/externalize/RelJson.java | 21 +- .../calcite/prepare/IgniteConvertletTable.java | 13 ++ .../query/calcite/prepare/IgniteSqlValidator.java | 19 +- .../query/calcite/rel/IgniteCollect.java | 14 +- .../calcite/sql/fun/IgniteStdSqlOperatorTable.java | 33 ++- .../integration/CollectIntegrationTest.java | 22 ++ .../integration/MultisetIntegrationTest.java | 235 +++++++++++++++++++++ .../calcite/integration/StdSqlOperatorsTest.java | 33 +++ .../calcite/planner/SerializationPlannerTest.java | 25 +++ .../ignite/testsuites/IntegrationTestSuite.java | 2 + 12 files changed, 429 insertions(+), 45 deletions(-) diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/RexImpTable.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/RexImpTable.java index e3e3ce5be27..1042f24a399 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/RexImpTable.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/RexImpTable.java @@ -184,6 +184,7 @@ import static org.apache.calcite.sql.fun.SqlStdOperatorTable.DEFAULT; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.DEGREES; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.DIVIDE; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.DIVIDE_INTEGER; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ELEMENT; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.EQUALS; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.EXP; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.EXTRACT; @@ -191,12 +192,14 @@ import static org.apache.calcite.sql.fun.SqlStdOperatorTable.FLOOR; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.GREATER_THAN; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.GREATER_THAN_OR_EQUAL; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.INITCAP; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_A_SET; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_EMPTY; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_FALSE; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_JSON_ARRAY; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_JSON_OBJECT; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_JSON_SCALAR; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_JSON_VALUE; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_NOT_A_SET; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_NOT_DISTINCT_FROM; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_NOT_EMPTY; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.IS_NOT_FALSE; @@ -225,14 +228,23 @@ import static org.apache.calcite.sql.fun.SqlStdOperatorTable.LOCALTIMESTAMP; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.LOG10; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.LOWER; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MAP_VALUE_CONSTRUCTOR; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MEMBER_OF; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MINUS; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MINUS_DATE; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MOD; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MULTIPLY; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MULTISET_EXCEPT; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MULTISET_EXCEPT_DISTINCT; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MULTISET_INTERSECT; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MULTISET_INTERSECT_DISTINCT; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MULTISET_UNION; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MULTISET_UNION_DISTINCT; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.MULTISET_VALUE; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_INSENSITIVE; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_SENSITIVE; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.NOT; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.NOT_EQUALS; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.NOT_SUBMULTISET_OF; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.OCTET_LENGTH; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.OR; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.OVERLAY; @@ -252,6 +264,9 @@ import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ROW; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SIGN; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SIMILAR_TO; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SIN; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SLICE; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.STRUCT_ACCESS; +import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SUBMULTISET_OF; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SUBSTRING; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.TAN; import static org.apache.calcite.sql.fun.SqlStdOperatorTable.TRIM; @@ -479,37 +494,35 @@ public class RexImpTable { defineMethod(CARDINALITY, BuiltInMethod.COLLECTION_SIZE.method, NullPolicy.STRICT); final MethodImplementor isEmptyImplementor = - new MethodImplementor(BuiltInMethod.IS_EMPTY.method, NullPolicy.NONE, + new MethodImplementor(BuiltInMethod.IS_EMPTY.method, NullPolicy.STRICT, false); map.put(IS_EMPTY, isEmptyImplementor); map.put(IS_NOT_EMPTY, NotImplementor.of(isEmptyImplementor)); - // TODO https://issues.apache.org/jira/browse/IGNITE-15551 -/* - defineMethod(SLICE, BuiltInMethod.SLICE.method, NullPolicy.NONE); + defineMethod(SLICE, BuiltInMethod.SLICE.method, NullPolicy.STRICT); defineMethod(ELEMENT, BuiltInMethod.ELEMENT.method, NullPolicy.STRICT); defineMethod(STRUCT_ACCESS, BuiltInMethod.STRUCT_ACCESS.method, NullPolicy.ANY); - defineMethod(MEMBER_OF, BuiltInMethod.MEMBER_OF.method, NullPolicy.NONE); + // TODO: Compare ROW elements by value; Calcite collection helpers use Object[].equals. + defineMethod(MEMBER_OF, BuiltInMethod.MEMBER_OF.method, NullPolicy.STRICT); final MethodImplementor isASetImplementor = - new MethodImplementor(BuiltInMethod.IS_A_SET.method, NullPolicy.NONE, + new MethodImplementor(BuiltInMethod.IS_A_SET.method, NullPolicy.STRICT, false); map.put(IS_A_SET, isASetImplementor); map.put(IS_NOT_A_SET, NotImplementor.of(isASetImplementor)); defineMethod(MULTISET_INTERSECT_DISTINCT, - BuiltInMethod.MULTISET_INTERSECT_DISTINCT.method, NullPolicy.NONE); + BuiltInMethod.MULTISET_INTERSECT_DISTINCT.method, NullPolicy.STRICT); defineMethod(MULTISET_INTERSECT, - BuiltInMethod.MULTISET_INTERSECT_ALL.method, NullPolicy.NONE); + BuiltInMethod.MULTISET_INTERSECT_ALL.method, NullPolicy.STRICT); defineMethod(MULTISET_EXCEPT_DISTINCT, - BuiltInMethod.MULTISET_EXCEPT_DISTINCT.method, NullPolicy.NONE); - defineMethod(MULTISET_EXCEPT, BuiltInMethod.MULTISET_EXCEPT_ALL.method, NullPolicy.NONE); + BuiltInMethod.MULTISET_EXCEPT_DISTINCT.method, NullPolicy.STRICT); + defineMethod(MULTISET_EXCEPT, BuiltInMethod.MULTISET_EXCEPT_ALL.method, NullPolicy.STRICT); defineMethod(MULTISET_UNION_DISTINCT, - BuiltInMethod.MULTISET_UNION_DISTINCT.method, NullPolicy.NONE); - defineMethod(MULTISET_UNION, BuiltInMethod.MULTISET_UNION_ALL.method, NullPolicy.NONE); + BuiltInMethod.MULTISET_UNION_DISTINCT.method, NullPolicy.STRICT); + defineMethod(MULTISET_UNION, BuiltInMethod.MULTISET_UNION_ALL.method, NullPolicy.STRICT); final MethodImplementor subMultisetImplementor = - new MethodImplementor(BuiltInMethod.SUBMULTISET_OF.method, NullPolicy.NONE, false); + new MethodImplementor(BuiltInMethod.SUBMULTISET_OF.method, NullPolicy.STRICT, false); map.put(SUBMULTISET_OF, subMultisetImplementor); map.put(NOT_SUBMULTISET_OF, NotImplementor.of(subMultisetImplementor)); -*/ map.put(COALESCE, new CoalesceImplementor()); map.put(CAST, new CastImplementor()); @@ -519,6 +532,7 @@ public class RexImpTable { final RexCallImplementor val = new ValueConstructorImplementor(); map.put(MAP_VALUE_CONSTRUCTOR, val); map.put(ARRAY_VALUE_CONSTRUCTOR, val); + map.put(MULTISET_VALUE, val); map.put(ITEM, new ItemImplementor()); map.put(DEFAULT, new DefaultImplementor()); @@ -1654,6 +1668,7 @@ public class RexImpTable { } return map; case ARRAY_VALUE_CONSTRUCTOR: + case MULTISET_VALUE_CONSTRUCTOR: Expression lyst = blockBuilder.append("list", Expressions.new_(ArrayList.class), false); diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/CollectNode.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/CollectNode.java index 468d7b3a837..481f2fd96af 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/CollectNode.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/CollectNode.java @@ -174,7 +174,10 @@ public class CollectNode<Row> extends MemoryTrackingNode<Row> implements SingleN switch (collectionType.getSqlTypeName()) { case ARRAY: - return new ArrayCollector<>(ctx.rowHandler(), rowFactory, IN_BUFFER_SIZE); + case MULTISET: + return new ArrayCollector<>(ctx.rowHandler(), rowFactory, IN_BUFFER_SIZE, + collectionType.getSqlTypeName() == SqlTypeName.MULTISET + && collectionType.getComponentType().isStruct()); case MAP: return new MapCollector<>(ctx.rowHandler(), rowFactory, IN_BUFFER_SIZE); default: @@ -265,6 +268,9 @@ public class CollectNode<Row> extends MemoryTrackingNode<Row> implements SingleN /** */ private static class ArrayCollector<Row> extends Collector<Row> { + /** */ + private final boolean structedType; + /** */ private List<Object> outBuf; @@ -272,9 +278,11 @@ public class CollectNode<Row> extends MemoryTrackingNode<Row> implements SingleN private ArrayCollector( RowHandler<Row> handler, RowHandler.RowFactory<Row> rowFactory, - int cap + int cap, + boolean structedType ) { super(handler, rowFactory, cap); + this.structedType = structedType; outBuf = new ArrayList<>(cap); } @@ -285,7 +293,7 @@ public class CollectNode<Row> extends MemoryTrackingNode<Row> implements SingleN /** {@inheritDoc} */ @Override public void push(Row row) { - if (rowHandler.columnCount(row) > 1) + if (structedType || rowHandler.columnCount(row) > 1) outBuf.add(row); else outBuf.add(rowHandler.get(0, row)); diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/externalize/RelJson.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/externalize/RelJson.java index a3501b46a07..bad07dd8ab1 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/externalize/RelJson.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/externalize/RelJson.java @@ -381,8 +381,11 @@ class RelJson { Object fields = map.get("fields"); - if (fields != null) - return toType(typeFactory, fields); + if (fields != null) { + RelDataType type = toType(typeFactory, fields); + + return Boolean.TRUE == map.get("nullable") ? typeFactory.createTypeWithNullability(type, true) : type; + } else { SqlTypeName sqlTypeName = toEnum(map.get("type")); Integer precision = (Integer)map.get("precision"); @@ -401,6 +404,8 @@ class RelJson { if (Boolean.TRUE == map.get("nullable")) type = typeFactory.createTypeWithNullability(type, true); } + else if (sqlTypeName == SqlTypeName.MULTISET) + type = typeFactory.createMultisetType(toType(typeFactory, map.get("elementType")), -1); else if (sqlTypeName == SqlTypeName.MAP) type = typeFactory.createMapType( toType(typeFactory, map.get("keyType")), @@ -790,9 +795,19 @@ class RelJson { List<Object> list = list(); for (RelDataTypeField field : node.getFieldList()) list.add(toJson(field)); + + // A nullable ROW must retain its nullability, independently of its fields' nullability. + if (node.isNullable()) { + Map<String, Object> map = map(); + map.put("fields", list); + map.put("nullable", true); + + return map; + } + return list; } - else if (node.getSqlTypeName() == SqlTypeName.ARRAY) { + else if (node.getSqlTypeName() == SqlTypeName.ARRAY || node.getSqlTypeName() == SqlTypeName.MULTISET) { Map<String, Object> map = map(); map.put("type", toJson(node.getSqlTypeName())); map.put("elementType", toJson(node.getComponentType())); diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteConvertletTable.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteConvertletTable.java index 77cd8ad0a9f..ab52d13d7b2 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteConvertletTable.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteConvertletTable.java @@ -27,6 +27,7 @@ import org.apache.calcite.rex.RexCall; import org.apache.calcite.rex.RexNode; import org.apache.calcite.sql.SqlCall; import org.apache.calcite.sql.SqlIntervalQualifier; +import org.apache.calcite.sql.SqlOperator; import org.apache.calcite.sql.fun.SqlLibraryOperators; import org.apache.calcite.sql.fun.SqlStdOperatorTable; import org.apache.calcite.sql.parser.SqlParserPos; @@ -54,6 +55,18 @@ public class IgniteConvertletTable extends ReflectiveConvertletTable { registerOp(SqlLibraryOperators.REGEXP_SUBSTR, (cx, call) -> cx.getRexBuilder().makeCall( SqlLibraryOperators.REGEXP_SUBSTR, Commons.transform(call.getOperandList(), cx::convertExpression))); + // Calcite declares these predicates non-nullable, but a null collection yields UNKNOWN. + for (SqlOperator op : ImmutableList.of(SqlStdOperatorTable.IS_EMPTY, SqlStdOperatorTable.IS_NOT_EMPTY, + SqlStdOperatorTable.IS_A_SET, SqlStdOperatorTable.IS_NOT_A_SET)) { + registerOp(op, (cx, call) -> { + RexNode operand = cx.convertExpression(call.operand(0)); + RelDataType type = cx.getTypeFactory().createTypeWithNullability( + cx.getTypeFactory().createSqlType(SqlTypeName.BOOLEAN), operand.getType().isNullable()); + + return cx.getRexBuilder().makeCall(type, call.getOperator(), ImmutableList.of(operand)); + }); + } + addAlias(IgniteOwnSqlOperatorTable.LENGTH, SqlStdOperatorTable.CHAR_LENGTH); } diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteSqlValidator.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteSqlValidator.java index 8b671e53d85..5daa8b4425e 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteSqlValidator.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/IgniteSqlValidator.java @@ -46,6 +46,7 @@ import org.apache.calcite.sql.SqlMerge; import org.apache.calcite.sql.SqlNode; import org.apache.calcite.sql.SqlNodeList; import org.apache.calcite.sql.SqlNumericLiteral; +import org.apache.calcite.sql.SqlOperator; import org.apache.calcite.sql.SqlOperatorTable; import org.apache.calcite.sql.SqlOrderBy; import org.apache.calcite.sql.SqlSelect; @@ -55,6 +56,7 @@ import org.apache.calcite.sql.SqlWindow; import org.apache.calcite.sql.SqlWithItem; import org.apache.calcite.sql.dialect.CalciteSqlDialect; import org.apache.calcite.sql.fun.SqlCase; +import org.apache.calcite.sql.fun.SqlStdOperatorTable; import org.apache.calcite.sql.parser.SqlParserPos; import org.apache.calcite.sql.type.FamilyOperandTypeChecker; import org.apache.calcite.sql.type.SqlOperandTypeChecker; @@ -736,7 +738,22 @@ public class IgniteSqlValidator extends SqlValidatorImpl { return type; } - return super.deriveType(scope, expr); + RelDataType type = super.deriveType(scope, expr); + + if (expr instanceof SqlCall) { + SqlCall call = (SqlCall)expr; + SqlOperator op = call.getOperator(); + + // Collection predicates yield UNKNOWN for a null collection. + if (op == SqlStdOperatorTable.IS_EMPTY || op == SqlStdOperatorTable.IS_NOT_EMPTY + || op == SqlStdOperatorTable.IS_A_SET || op == SqlStdOperatorTable.IS_NOT_A_SET) { + type = typeFactory.createTypeWithNullability(type, deriveType(scope, call.operand(0)).isNullable()); + + setValidatedNodeType(expr, type); + } + } + + return type; } /** */ diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/rel/IgniteCollect.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/rel/IgniteCollect.java index 70dcfb7cb2b..6f4643a1554 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/rel/IgniteCollect.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/rel/IgniteCollect.java @@ -26,13 +26,10 @@ import org.apache.calcite.rel.RelNode; import org.apache.calcite.rel.RelWriter; import org.apache.calcite.rel.core.Collect; import org.apache.calcite.rel.type.RelDataType; -import org.apache.calcite.sql.type.SqlTypeName; import org.apache.calcite.util.Pair; import org.apache.ignite.internal.processors.query.calcite.trait.IgniteDistributions; import org.apache.ignite.internal.processors.query.calcite.trait.TraitUtils; -import static java.util.Objects.requireNonNull; - /** */ public class IgniteCollect extends Collect implements IgniteRel { /** @@ -58,9 +55,12 @@ public class IgniteCollect extends Collect implements IgniteRel { * @param input Serialized representation. */ public IgniteCollect(RelInput input) { - super(input.getCluster(), input.getTraitSet().replace(IgniteConvention.INSTANCE), input.getInput(), - deriveRowType(input.getCluster().getTypeFactory(), input.getEnum("collectionType", SqlTypeName.class), - requireNonNull(input.getString("field"), "field"), input.getInput().getRowType())); + super( + input.getCluster(), + input.getTraitSet().replace(IgniteConvention.INSTANCE), + input.getInput(), + input.getRowType("rowType") + ); } /** {@inheritDoc} */ @@ -80,7 +80,7 @@ public class IgniteCollect extends Collect implements IgniteRel { /** {@inheritDoc} */ @Override public RelWriter explainTerms(RelWriter pw) { - return super.explainTerms(pw).item("collectionType", getCollectionType()); + return super.explainTerms(pw).item("collectionType", getCollectionType()).item("rowType", getRowType()); } /** {@inheritDoc} */ diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/fun/IgniteStdSqlOperatorTable.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/fun/IgniteStdSqlOperatorTable.java index b573a014cb3..432cf46c373 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/fun/IgniteStdSqlOperatorTable.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/fun/IgniteStdSqlOperatorTable.java @@ -252,23 +252,22 @@ public class IgniteStdSqlOperatorTable extends ReflectiveSqlOperatorTable { register(SqlStdOperatorTable.ARRAY_QUERY); // Multiset. - // TODO https://issues.apache.org/jira/browse/IGNITE-15551 - //register(SqlStdOperatorTable.MULTISET_VALUE); - //register(SqlStdOperatorTable.MULTISET_QUERY); - //register(SqlStdOperatorTable.SLICE); - //register(SqlStdOperatorTable.ELEMENT); - //register(SqlStdOperatorTable.STRUCT_ACCESS); - //register(SqlStdOperatorTable.MEMBER_OF); - //register(SqlStdOperatorTable.IS_A_SET); - //register(SqlStdOperatorTable.IS_NOT_A_SET); - //register(SqlStdOperatorTable.MULTISET_INTERSECT_DISTINCT); - //register(SqlStdOperatorTable.MULTISET_INTERSECT); - //register(SqlStdOperatorTable.MULTISET_EXCEPT_DISTINCT); - //register(SqlStdOperatorTable.MULTISET_EXCEPT); - //register(SqlStdOperatorTable.MULTISET_UNION_DISTINCT); - //register(SqlStdOperatorTable.MULTISET_UNION); - //register(SqlStdOperatorTable.SUBMULTISET_OF); - //register(SqlStdOperatorTable.NOT_SUBMULTISET_OF); + register(SqlStdOperatorTable.MULTISET_VALUE); + register(SqlStdOperatorTable.MULTISET_QUERY); + register(SqlStdOperatorTable.SLICE); + register(SqlStdOperatorTable.ELEMENT); + register(SqlStdOperatorTable.STRUCT_ACCESS); + register(SqlStdOperatorTable.MEMBER_OF); + register(SqlStdOperatorTable.IS_A_SET); + register(SqlStdOperatorTable.IS_NOT_A_SET); + register(SqlStdOperatorTable.MULTISET_INTERSECT_DISTINCT); + register(SqlStdOperatorTable.MULTISET_INTERSECT); + register(SqlStdOperatorTable.MULTISET_EXCEPT_DISTINCT); + register(SqlStdOperatorTable.MULTISET_EXCEPT); + register(SqlStdOperatorTable.MULTISET_UNION_DISTINCT); + register(SqlStdOperatorTable.MULTISET_UNION); + register(SqlStdOperatorTable.SUBMULTISET_OF); + register(SqlStdOperatorTable.NOT_SUBMULTISET_OF); // Other fuctions and operators. register(SqlStdOperatorTable.ROW); diff --git a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/CollectIntegrationTest.java b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/CollectIntegrationTest.java index 726a3453e1b..1531d828277 100644 --- a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/CollectIntegrationTest.java +++ b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/CollectIntegrationTest.java @@ -49,4 +49,26 @@ public class CollectIntegrationTest extends AbstractBasicIntegrationTest { assertQuery(sql).resultSize(1).check(); } + + /** Tests multiset collection from distributed and correlated queries. */ + @Test + public void testMultisetQueries() { + sql("CREATE TABLE t(id INT PRIMARY KEY, val INT)"); + sql("INSERT INTO t VALUES (1, 10), (2, 10), (3, 20), (4, NULL)"); + + assertQuery("SELECT * FROM UNNEST(MULTISET(SELECT val FROM t))") + .returns(10).returns(10).returns(20).returns(NULL_RESULT).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET(SELECT id, val FROM t))") + .returns(1, 10).returns(2, 10).returns(3, 20).returns(4, null).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[ROW(1), ROW(2)])") + .returns(1).returns(2).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[ROW(1, 10), ROW(2, 20)])") + .returns(1, 10).returns(2, 20).check(); + assertQuery("SELECT id, CARDINALITY(MULTISET(SELECT b.val FROM t b WHERE b.val = a.val)) FROM t a") + .returns(1, 2).returns(2, 2).returns(3, 1).returns(4, 0).check(); + assertQuery("SELECT id, CARDINALITY(MULTISET[val, val]) FROM t") + .returns(1, 2).returns(2, 2).returns(3, 2).returns(4, 2).check(); + assertQuery("SELECT CARDINALITY(MULTISET(SELECT val FROM t) MULTISET UNION ALL " + + "MULTISET(SELECT val FROM t))").returns(8).check(); + } } diff --git a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/MultisetIntegrationTest.java b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/MultisetIntegrationTest.java new file mode 100644 index 00000000000..f050ecbd8dd --- /dev/null +++ b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/MultisetIntegrationTest.java @@ -0,0 +1,235 @@ +/* + * 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.util.Arrays; +import java.util.Collections; +import org.apache.calcite.runtime.CalciteException; +import org.apache.ignite.internal.processors.query.calcite.QueryChecker; +import org.junit.Test; + +/** Tests multiset constructors, predicates, and functions, including duplicate multiplicities. */ +public class MultisetIntegrationTest extends AbstractBasicIntegrationTest { + /** An empty collection with a known element type. */ + private static final String EMPTY = "MULTISET(SELECT val FROM t WHERE FALSE)"; + + /** A null collection with a known element type. */ + private static final String NULL_MULTISET = "CAST(NULL AS INTEGER MULTISET)"; + + /** Collections with unequal multiplicities and null elements. */ + private static final String LEFT = "MULTISET[3, 1, 1, CAST(NULL AS INTEGER), CAST(NULL AS INTEGER)]"; + + /** */ + private static final String RIGHT = "MULTISET[1, 2, CAST(NULL AS INTEGER)]"; + + /** {@inheritDoc} */ + @Override protected void beforeTest() throws Exception { + super.beforeTest(); + + sql("CREATE TABLE t(val INT)"); + sql("INSERT INTO t VALUES (1)"); + } + + /** Scalar constructors exercise the internal SLICE operation, which removes the temporary ROW wrapper. */ + @Test + public void testConstructors() { + assertExpression("MULTISET[val, val + 1, val]").returns(Arrays.asList(1, 2, 1)).check(); + assertExpression("CARDINALITY(MULTISET[val, CAST(NULL AS INTEGER)])").returns(2).check(); + assertQuery("SELECT x.v FROM t, UNNEST(MULTISET[val, val + 1, CAST(NULL AS INTEGER)]) AS x(v)") + .returns(1).returns(2).returns(NULL_RESULT).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[ROW(1), ROW(2)])").returns(1).returns(2).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[ROW(1, 'a'), ROW(2, CAST(NULL AS VARCHAR))])") + .returns(1, "a").returns(2, null).check(); + assertExpression(EMPTY).returns(Collections.emptyList()).check(); + assertExpression("CARDINALITY(" + EMPTY + ")").returns(0).check(); + assertExpression(EMPTY + " IS EMPTY").returns(true).check(); + assertExpression(EMPTY + " IS NOT EMPTY").returns(false).check(); + + sql("INSERT INTO t VALUES (1), (2), (NULL)"); + + assertMultiset("MULTISET(SELECT val FROM t)", 1, 1, 2, null); + assertMultiset("MULTISET(SELECT DISTINCT val FROM t)", 1, 2, null); + assertQuery("SELECT * FROM UNNEST(MULTISET(SELECT val, val + 10 FROM t))") + .returns(1, 11).returns(1, 11).returns(2, 12).returns(null, null).check(); + } + + /** ELEMENT returns null for empty collections and rejects multiple elements, even equal ones. */ + @Test + public void testElement() { + assertExpression("ELEMENT(MULTISET[val + 10])").returns(11).check(); + assertExpression("ELEMENT(MULTISET[CAST(NULL AS INTEGER)])").returns(NULL_RESULT).check(); + assertExpression("ELEMENT(" + EMPTY + ")").returns(NULL_RESULT).check(); + assertExpression("ELEMENT(" + NULL_MULTISET + ")").returns(NULL_RESULT).check(); + + assertThrows("SELECT ELEMENT(MULTISET[1, 2])", CalciteException.class, "More than one value"); + assertThrows("SELECT ELEMENT(MULTISET[1, 1])", CalciteException.class, "More than one value"); + } + + /** Field access on an extracted ROW exercises the internal STRUCT_ACCESS operation. */ + @Test + public void testStructAccess() { + String qry = "SELECT s.r.a, s.r.b FROM (SELECT ELEMENT(CAST(? AS " + + "ROW(a INTEGER, b VARCHAR(10)) MULTISET)) AS r FROM t) AS s"; + + assertQuery(qry).withParams(Collections.singletonList(new Object[] {1, "a"})).returns(1, "a").check(); + assertQuery(qry).withParams(Collections.singletonList(new Object[] {2, null})).returns(2, null).check(); + assertQuery(qry).withParams(Collections.emptyList()).returns(null, null).check(); + assertQuery(qry).withParams(new Object[] {null}).returns(null, null).check(); + assertQuery("SELECT s.r.a IS NULL FROM (SELECT ELEMENT(CAST(? AS " + + "ROW(a INTEGER, b VARCHAR(10)) MULTISET)) AS r FROM t) AS s") + .withParams(Collections.emptyList()).returns(true).check(); + } + + /** Membership and set predicates handle empty collections and distinguish one null from repeated nulls. */ + @Test + public void testMembershipAndSetPredicates() { + assertExpression("val MEMBER OF MULTISET[2, val, val]").returns(true).check(); + assertExpression("(val + 1) MEMBER OF MULTISET[val, val]").returns(false).check(); + assertExpression("val MEMBER OF " + EMPTY).returns(false).check(); + assertExpression("val MEMBER OF MULTISET[CAST(NULL AS INTEGER), val]").returns(true).check(); + assertExpression("val MEMBER OF " + NULL_MULTISET).returns(NULL_RESULT).check(); + assertExpression("CAST(NULL AS INTEGER) MEMBER OF MULTISET[val]").returns(NULL_RESULT).check(); + + for (String multiset : Arrays.asList(EMPTY, "MULTISET[2, val]", "MULTISET[CAST(NULL AS INTEGER)]")) { + assertExpression(multiset + " IS A SET").returns(true).check(); + assertExpression(multiset + " IS NOT A SET").returns(false).check(); + } + + for (String multiset : Arrays.asList("MULTISET[val, val]", + "MULTISET[CAST(NULL AS INTEGER), CAST(NULL AS INTEGER)]")) { + assertExpression(multiset + " IS A SET").returns(false).check(); + assertExpression(multiset + " IS NOT A SET").returns(true).check(); + } + } + + /** UNION ALL adds multiplicities; DISTINCT removes repeats, including repeated nulls. */ + @Test + public void testUnion() { + for (String op : Arrays.asList("UNION", "UNION ALL")) { + assertMultiset(LEFT + " MULTISET " + op + " " + RIGHT, 3, 1, 1, null, null, 1, 2, null); + assertMultiset(LEFT + " MULTISET " + op + " " + EMPTY, 3, 1, 1, null, null); + assertMultiset(EMPTY + " MULTISET " + op + " " + LEFT, 3, 1, 1, null, null); + } + + assertMultiset(LEFT + " MULTISET UNION DISTINCT " + RIGHT, 3, 1, 2, null); + assertMultiset(LEFT + " MULTISET UNION DISTINCT " + EMPTY, 3, 1, null); + assertMultiset(EMPTY + " MULTISET UNION DISTINCT " + LEFT, 3, 1, null); + } + + /** INTERSECT ALL takes the smaller multiplicity of each common element. */ + @Test + public void testIntersect() { + for (String op : Arrays.asList("INTERSECT", "INTERSECT ALL", "INTERSECT DISTINCT")) { + assertMultiset(LEFT + " MULTISET " + op + " " + RIGHT, 1, null); + assertMultiset(LEFT + " MULTISET " + op + " " + EMPTY); + assertMultiset(EMPTY + " MULTISET " + op + " " + LEFT); + assertMultiset("MULTISET[1, 1] MULTISET " + op + " MULTISET[2, 2]"); + } + + assertMultiset(LEFT + " MULTISET INTERSECT ALL " + LEFT, 3, 1, 1, null, null); + assertMultiset(LEFT + " MULTISET INTERSECT DISTINCT " + LEFT, 3, 1, null); + } + + /** EXCEPT ALL subtracts multiplicities; DISTINCT removes all matching values. */ + @Test + public void testExcept() { + for (String op : Arrays.asList("EXCEPT", "EXCEPT ALL")) { + assertMultiset(LEFT + " MULTISET " + op + " " + RIGHT, 3, 1, null); + assertMultiset(RIGHT + " MULTISET " + op + " " + LEFT, 2); + assertMultiset(LEFT + " MULTISET " + op + " " + EMPTY, 3, 1, 1, null, null); + assertMultiset(EMPTY + " MULTISET " + op + " " + LEFT); + assertMultiset(LEFT + " MULTISET " + op + " " + LEFT); + } + + assertMultiset(LEFT + " MULTISET EXCEPT DISTINCT " + RIGHT, 3); + assertMultiset(LEFT + " MULTISET EXCEPT DISTINCT " + EMPTY, 3, 1, null); + assertMultiset(EMPTY + " MULTISET EXCEPT DISTINCT " + LEFT); + } + + /** SUBMULTISET checks multiplicities rather than only membership, independently of order. */ + @Test + public void testSubmultiset() { + for (String predicate : Arrays.asList("SUBMULTISET OF", "NOT SUBMULTISET OF")) { + boolean negated = predicate.startsWith("NOT"); + + assertExpression("MULTISET[2, 1, 1] " + predicate + " MULTISET[1, 2, 1]").returns(!negated).check(); + assertExpression("MULTISET[1, 1] " + predicate + " MULTISET[1, 2, 3]").returns(negated).check(); + assertExpression("MULTISET[4] " + predicate + " MULTISET[1, 2, 3]").returns(negated).check(); + assertExpression(EMPTY + " " + predicate + " MULTISET[val]").returns(!negated).check(); + assertExpression(EMPTY + " " + predicate + " " + EMPTY).returns(!negated).check(); + assertExpression("MULTISET[val] " + predicate + " " + EMPTY).returns(negated).check(); + assertExpression(RIGHT + " " + predicate + " " + LEFT).returns(negated).check(); + assertExpression("MULTISET[CAST(NULL AS INTEGER)] " + predicate + " " + LEFT) + .returns(!negated).check(); + assertExpression(NULL_MULTISET + " " + predicate + " MULTISET[val]").returns(NULL_RESULT).check(); + assertExpression("MULTISET[val] " + predicate + " " + NULL_MULTISET).returns(NULL_RESULT).check(); + } + } + + /** Null propagation is checked with computed operands so optimizers cannot rely on literal folding alone. */ + @Test + public void testNullPropagation() { + String nullable = "(CASE WHEN val = 1 THEN " + NULL_MULTISET + " ELSE MULTISET[val] END)"; + + assertExpression("CARDINALITY(" + nullable + ")").returns(NULL_RESULT).check(); + + for (String op : Arrays.asList("UNION ALL", "UNION DISTINCT", "INTERSECT ALL", "INTERSECT DISTINCT", + "EXCEPT ALL", "EXCEPT DISTINCT")) { + assertExpression(nullable + " MULTISET " + op + " MULTISET[val]").returns(NULL_RESULT).check(); + assertExpression("MULTISET[val] MULTISET " + op + " " + nullable).returns(NULL_RESULT).check(); + } + + for (String predicate : Arrays.asList("IS EMPTY", "IS NOT EMPTY", "IS A SET", "IS NOT A SET")) { + assertExpression(NULL_MULTISET + " " + predicate).returns(NULL_RESULT).check(); + assertExpression(nullable + " " + predicate).returns(NULL_RESULT).check(); + assertExpression("(" + nullable + " " + predicate + ") IS NULL").returns(true).check(); + } + + // IS EMPTY shares its implementation with ARRAY, so preserve null propagation for that type too. + assertExpression("CAST(NULL AS INTEGER ARRAY) IS EMPTY").returns(NULL_RESULT).check(); + } + + /** A typed collection parameter retains duplicates and supports empty and null collections. */ + @Test + public void testParameters() { + String qry = "SELECT * FROM UNNEST(CAST(? AS INTEGER MULTISET))"; + + assertQuery(qry).withParams(Arrays.asList(2, 1, 1, null)).returns(2).returns(1).returns(1) + .returns(NULL_RESULT).check(); + assertQuery(qry).withParams(Collections.emptyList()).resultSize(0).check(); + assertQuery(qry).withParams(new Object[] {null}).resultSize(0).check(); + assertExpression("MULTISET[?, ?, ?]").withParams(1, 1, 2).returns(Arrays.asList(1, 1, 2)).check(); + assertQuery("SELECT MULTISET[?, ?, ?]").withParams(1, 1, 2).returns(Arrays.asList(1, 1, 2)).check(); + assertQuery("SELECT CARDINALITY(MULTISET[?, ?, ?])").withParams(1, 1, 2).returns(3).check(); + } + + /** Tests expressions on a distributed table, including plan serialization. */ + private QueryChecker assertExpression(String expr) { + return assertQuery("SELECT " + expr + " FROM t"); + } + + /** Compares the elements and their multiplicities without depending on the multiset's iteration order. */ + private void assertMultiset(String expr, Object... exp) { + QueryChecker checker = assertQuery("SELECT * FROM UNNEST(" + expr + ")").resultSize(exp.length); + + for (Object val : exp) + checker.returns(new Object[] {val}); + + checker.check(); + } +} diff --git a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/StdSqlOperatorsTest.java b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/StdSqlOperatorsTest.java index 2f78ee9c6f7..b793e05dde6 100644 --- a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/StdSqlOperatorsTest.java +++ b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/StdSqlOperatorsTest.java @@ -384,6 +384,39 @@ public class StdSqlOperatorsTest extends AbstractBasicIntegrationTest { assertExpression("NTH_VALUE(val, 1) OVER()").returns(1).check(); } + /** */ + @Test + public void testMultisets() { + // Scalar constructors exercise SLICE, which removes the temporary ROW wrapper. + assertExpression("MULTISET[1, 2]").returns(Arrays.asList(1, 2)).check(); + assertExpression("MULTISET(SELECT val FROM t)").returns(Collections.singletonList(1)).check(); + assertExpression("CARDINALITY(MULTISET[1, 2])").returns(2).check(); + assertExpression("MULTISET[1] IS EMPTY").returns(false).check(); + assertExpression("MULTISET[1] IS NOT EMPTY").returns(true).check(); + assertExpression("ELEMENT(MULTISET[1])").returns(1).check(); + assertQuery("SELECT s.r.a FROM (SELECT ELEMENT(CAST(? AS ROW(a INTEGER, b INTEGER) MULTISET)) " + + "AS r FROM t) AS s").withParams(Collections.singletonList(new Object[] {1, 2})).returns(1).check(); + assertExpression("1 MEMBER OF MULTISET[1, 2]").returns(true).check(); + assertExpression("MULTISET[1, 2] IS A SET").returns(true).check(); + assertExpression("MULTISET[1, 1] IS NOT A SET").returns(true).check(); + assertExpression("MULTISET[1] SUBMULTISET OF MULTISET[1, 2]").returns(true).check(); + assertExpression("MULTISET[3] NOT SUBMULTISET OF MULTISET[1, 2]").returns(true).check(); + + assertQuery("SELECT * FROM UNNEST(MULTISET[1, 2])").returns(1).returns(2).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[1, 2] MULTISET UNION ALL MULTISET[2, 3])") + .returns(1).returns(2).returns(2).returns(3).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[1, 2] MULTISET UNION DISTINCT MULTISET[2, 3])") + .returns(1).returns(2).returns(3).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[1, 2] MULTISET INTERSECT ALL MULTISET[2, 3])") + .returns(2).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[1, 2] MULTISET INTERSECT DISTINCT MULTISET[2, 3])") + .returns(2).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[1, 2] MULTISET EXCEPT ALL MULTISET[2, 3])") + .returns(1).check(); + assertQuery("SELECT * FROM UNNEST(MULTISET[1, 2] MULTISET EXCEPT DISTINCT MULTISET[2, 3])") + .returns(1).check(); + } + /** */ private QueryChecker assertExpression(String qry) { // Select expressions from table to test plan serialization containing these expressions. diff --git a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/SerializationPlannerTest.java b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/SerializationPlannerTest.java index bc2ff7e89fe..7532026ed8e 100644 --- a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/SerializationPlannerTest.java +++ b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/SerializationPlannerTest.java @@ -107,6 +107,31 @@ public class SerializationPlannerTest extends AbstractPlannerTest { isTableScan("ORDERS")); } + /** */ + @Test + public void testMultisetSerialization() throws Exception { + IgniteSchema publicSchema = createSchema( + createTable("TEST", IgniteDistributions.affinity(0, "TEST", "hash"), + "ID", Integer.class, "VAL", String.class) + ); + + String[] queries = { + "SELECT MULTISET[id, id] FROM test", + "SELECT MULTISET(SELECT val FROM test)", + "SELECT MULTISET(SELECT id, val FROM test)", + "SELECT CAST(NULL AS INTEGER MULTISET) FROM test", + "SELECT CAST(NULL AS INTEGER MULTISET MULTISET) FROM test", + "SELECT MULTISET[id] MULTISET UNION DISTINCT MULTISET[1] FROM test", + "SELECT CAST(NULL AS ROW(a INTEGER, b INTEGER)) FROM test", + "SELECT ELEMENT(MULTISET[CAST(ROW(id, val) AS ROW(a INTEGER, b VARCHAR(10)))]) FROM test", + "SELECT s.r.a, s.r.b FROM (SELECT ELEMENT(MULTISET[CAST(ROW(id, val) AS " + + "ROW(a INTEGER, b VARCHAR(10)))]) AS r FROM test) AS s" + }; + + for (String sql : queries) + checkSplitAndSerialization(physicalPlan(sql, publicSchema), publicSchema); + } + /** */ public static int echo(int val) { return val; 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 c9605a431cd..5df442afeb3 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 @@ -60,6 +60,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.MultisetIntegrationTest; 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; @@ -199,6 +200,7 @@ import org.junit.runners.Suite; BulkOperationDeadlockIntegrationTest.class, SelectForUpdateIntegrationTest.class, ResultSetSizeMetricsTest.class, + MultisetIntegrationTest.class, }) public class IntegrationTestSuite { }
