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 {
 }

Reply via email to