IGNITE-28801 Calcite. Bump calcite dependency version to 1.42

modules/calcite/pom.xml

@@ -35,8 +35,8 @@
 
     <!-- Module specific package versions -->
     <properties>
-        <avatica.version>1.26.0</avatica.version>
-        <calcite.version>1.40.0</calcite.version>
+        <avatica.version>1.28.0</avatica.version>
+        <calcite.version>1.42.0</calcite.version>
         <failureaccess.version>1.0.1</failureaccess.version>
         <immutables.version>2.8.2</immutables.version>
         <janino.version>3.1.12</janino.version>

modules/calcite/src/main/codegen/config.fmpp

@@ -387,6 +387,7 @@ data: {
       "UESCAPE"
       "UNIQUE"
       "UNKNOWN"
+      "UNSIGNED"
       "UPPER"
       "UPSERT"
       "UUID"

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/LogicalRelImplementor.java

@@ -27,6 +27,7 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
+import com.google.common.collect.ImmutableList;
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.rel.RelFieldCollation;
 import org.apache.calcite.rel.RelNode;
@@ -90,7 +91,6 @@
 import org.apache.ignite.internal.processors.query.calcite.rel.IgniteIndexBound;
 import org.apache.ignite.internal.processors.query.calcite.rel.IgniteIndexCount;
 import org.apache.ignite.internal.processors.query.calcite.rel.IgniteIndexScan;
-import org.apache.ignite.internal.processors.query.calcite.rel.IgniteJoinInfo;
 import org.apache.ignite.internal.processors.query.calcite.rel.IgniteLimit;
 import org.apache.ignite.internal.processors.query.calcite.rel.IgniteMergeJoin;
 import org.apache.ignite.internal.processors.query.calcite.rel.IgniteNestedLoopJoin;
@@ -288,8 +288,6 @@ public LogicalRelImplementor(
         RelDataType rightType = rel.getRight().getRowType();
         JoinRelType joinType = rel.getJoinType();
 
-        IgniteJoinInfo joinInfo = IgniteJoinInfo.of(rel);
-
         RexNode nonEquiConditionExpression = RexUtil.composeConjunction(Commons.emptyCluster().getRexBuilder(),
             rel.analyzeCondition().nonEquiConditions, true);
 
@@ -301,7 +299,7 @@ public LogicalRelImplementor(
             nonEquiCondition = expressionFactory.biPredicate(rel.getCondition(), rowType);
         }
 
-        Node<Row> node = HashJoinNode.create(ctx, outType, leftType, rightType, joinType, joinInfo,
+        Node<Row> node = HashJoinNode.create(ctx, outType, leftType, rightType, joinType, rel.analyzeCondition(),
             nonEquiCondition);
 
         node.register(Arrays.asList(visit(rel.getLeft()), visit(rel.getRight())));
@@ -345,23 +343,23 @@ public LogicalRelImplementor(
         List<RelFieldCollation> leftCollations = rel.leftCollation().getFieldCollations();
         List<RelFieldCollation> rightCollations = rel.rightCollation().getFieldCollations();
 
-        ImmutableBitSet allowNulls = rel.allowNulls();
-        ImmutableBitSet.Builder collsAllowNullsBuilder = ImmutableBitSet.builder();
+        ImmutableList<Boolean> nullExclusions = rel.analyzeCondition().nullExclusionFlags;
+        ImmutableBitSet.Builder nullCompAsEqual = ImmutableBitSet.builder();
         int lastCollField = -1;
 
         for (int c = 0; c < Math.min(leftCollations.size(), rightCollations.size()); ++c) {
             RelFieldCollation leftColl = leftCollations.get(c);
             RelFieldCollation rightColl = rightCollations.get(c);
-            collsAllowNullsBuilder.set(c);
+            nullCompAsEqual.set(c);
 
             for (int p = 0; p < pairsCnt; ++p) {
                 IntPair pair = joinPairs.get(p);
 
                 if (pair.source == leftColl.getFieldIndex() && pair.target == rightColl.getFieldIndex()) {
                     lastCollField = c;
 
-                    if (!allowNulls.get(p)) {
-                        collsAllowNullsBuilder.clear(c);
+                    if (nullExclusions.get(p)) {
+                        nullCompAsEqual.clear(c);
 
                         break;
                     }
@@ -372,7 +370,7 @@ public LogicalRelImplementor(
         Comparator<Row> comp = expressionFactory.comparator(
             leftCollations.subList(0, lastCollField + 1),
             rightCollations.subList(0, lastCollField + 1),
-            collsAllowNullsBuilder.build()
+            nullCompAsEqual.build()
         );
 
         Node<Row> node = MergeJoinNode.create(ctx, outType, leftType, rightType, joinType, comp, hasExchange(rel));

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/ConverterUtils.java

@@ -419,6 +419,20 @@ else if (fromType == BigDecimal.class) {
         }
         else if (toType == UUID.class && fromType == String.class)
             return Expressions.call(UUID.class, "fromString", operand);
+        else if (fromType == Object.class && Number.class.isAssignableFrom((Class<?>)toType)) {
+            Primitive primitiveFromToType = Primitive.ofBox(toType);
+            if (primitiveFromToType != null) {
+                Expression res = Expressions.convert_(operand, Number.class);
+
+                res = Expressions.condition(
+                    Expressions.equal(res, RexImpTable.NULL_EXPR),
+                    RexImpTable.NULL_EXPR,
+                    Expressions.unbox(res, primitiveFromToType));
+
+                res = Expressions.box(res);
+                return res;
+            }
+        }
 
         return Expressions.convert_(operand, toType);
     }

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/IgniteExpressions.java

@@ -32,13 +32,13 @@ public class IgniteExpressions {
     /** Make binary expression with arithmetic operations override. */
     public static Expression makeBinary(ExpressionType binaryType, Expression left, Expression right) {
         switch (binaryType) {
-            case Add:
+            case Add, AddChecked:
                 return addExact(left, right);
-            case Subtract:
+            case Subtract, SubtractChecked:
                 return subtractExact(left, right);
-            case Multiply:
+            case Multiply, MultiplyChecked:
                 return multiplyExact(left, right);
-            case Divide:
+            case Divide, DivideChecked:
                 return divideExact(left, right);
             default:
                 return Expressions.makeBinary(binaryType, left, right);

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/RexImpTable.java

@@ -78,16 +78,21 @@
 import static java.util.Objects.requireNonNull;
 import static org.apache.calcite.adapter.enumerable.EnumUtils.generateCollatorExpression;
 import static org.apache.calcite.linq4j.tree.ExpressionType.Add;
+import static org.apache.calcite.linq4j.tree.ExpressionType.AddChecked;
 import static org.apache.calcite.linq4j.tree.ExpressionType.Divide;
+import static org.apache.calcite.linq4j.tree.ExpressionType.DivideChecked;
 import static org.apache.calcite.linq4j.tree.ExpressionType.Equal;
 import static org.apache.calcite.linq4j.tree.ExpressionType.GreaterThan;
 import static org.apache.calcite.linq4j.tree.ExpressionType.GreaterThanOrEqual;
 import static org.apache.calcite.linq4j.tree.ExpressionType.LessThan;
 import static org.apache.calcite.linq4j.tree.ExpressionType.LessThanOrEqual;
 import static org.apache.calcite.linq4j.tree.ExpressionType.Multiply;
+import static org.apache.calcite.linq4j.tree.ExpressionType.MultiplyChecked;
 import static org.apache.calcite.linq4j.tree.ExpressionType.Negate;
+import static org.apache.calcite.linq4j.tree.ExpressionType.NegateChecked;
 import static org.apache.calcite.linq4j.tree.ExpressionType.NotEqual;
 import static org.apache.calcite.linq4j.tree.ExpressionType.Subtract;
+import static org.apache.calcite.linq4j.tree.ExpressionType.SubtractChecked;
 import static org.apache.calcite.linq4j.tree.ExpressionType.UnaryPlus;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.ACOSH;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.ASINH;
@@ -162,6 +167,7 @@
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CEIL;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CHAR_LENGTH;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CHECKED_DIVIDE;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CHECKED_DIVIDE_INTEGER;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CHECKED_MINUS;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CHECKED_MULTIPLY;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CHECKED_PLUS;
@@ -344,6 +350,13 @@ public class RexImpTable {
         defineUnary(UNARY_MINUS, Negate, NullPolicy.STRICT,
             BuiltInMethod.BIG_DECIMAL_NEGATE.getMethodName());
         defineUnary(UNARY_PLUS, UnaryPlus, NullPolicy.STRICT, null);
+        // checked arithmetic
+        defineBinary(CHECKED_PLUS, AddChecked, NullPolicy.STRICT, "checkedPlus");
+        defineBinary(CHECKED_MINUS, SubtractChecked, NullPolicy.STRICT, "checkedMinus");
+        defineBinary(CHECKED_MULTIPLY, MultiplyChecked, NullPolicy.STRICT, "checkedMultiply");
+        defineBinary(CHECKED_DIVIDE, DivideChecked, NullPolicy.STRICT, "checkedDivide");
+        defineBinary(CHECKED_DIVIDE_INTEGER, DivideChecked, NullPolicy.STRICT, "checkedDivide");
+        defineUnary(CHECKED_UNARY_MINUS, NegateChecked, NullPolicy.STRICT, "checkedUnaryMinus");
 
         defineMethod(MOD, "mod", NullPolicy.STRICT);
         defineMethod(EXP, "exp", NullPolicy.STRICT);
@@ -1227,7 +1240,7 @@ private static class BinaryImplementor extends AbstractRexCallImplementor {
         @Override Expression implementSafe(
             final RexToLixTranslator translator,
             final RexCall call,
-            final List<Expression> argValueList) {
+            List<Expression> argValueList) {
             // neither nullable:
             //   return x OP y
             // x nullable
@@ -1243,7 +1256,7 @@ private static class BinaryImplementor extends AbstractRexCallImplementor {
             // If one or both operands have ANY type, use the late-binding backup
             // method.
             if (anyAnyOperands(call))
-                return callBackupMethodAnyType(translator, call, argValueList);
+                return callBackupMethodAnyType(argValueList);
 
             final Type type0 = argValueList.get(0).getType();
             final Type type1 = argValueList.get(1).getType();
@@ -1272,10 +1285,6 @@ private static class BinaryImplementor extends AbstractRexCallImplementor {
                     argValueList);
             }
 
-            // For checked arithmetic call the method.
-            if (CHECKED_OPERATORS.contains(op))
-                return Expressions.call(SqlFunctions.class, backupMethodName, argValueList);
-
             return IgniteExpressions.makeBinary(expressionType,
                 argValueList.get(0), argValueList.get(1));
         }
@@ -1290,8 +1299,7 @@ private boolean anyAnyOperands(RexCall call) {
         }
 
         /** */
-        private Expression callBackupMethodAnyType(RexToLixTranslator translator,
-            RexCall call, List<Expression> expressions) {
+        private Expression callBackupMethodAnyType(List<Expression> expressions) {
             final String backupMethodNameForAnyType =
                 backupMethodName + METHOD_POSTFIX_FOR_ANY_TYPE;
 
@@ -1343,6 +1351,8 @@ private static class UnaryImplementor extends AbstractRexCallImplementor {
             if (expressionType == ExpressionType.Negate && argVal.type == BigDecimal.class
                 && null != backupMethodName)
                 e = Expressions.call(argVal, backupMethodName);
+            else if (expressionType == NegateChecked && null != backupMethodName)
+                e = Expressions.call(SqlFunctions.class, backupMethodName, argValueList);
             else
                 e = IgniteExpressions.makeUnary(expressionType, argVal);
 
@@ -1565,9 +1575,12 @@ private static class CastImplementor extends AbstractRexCallImplementor {
             assert call.getOperands().size() == 1;
             final RelDataType srcType = call.getOperands().get(0).getType();
 
-            // Short-circuit if no cast is required
             RexNode arg = call.getOperands().get(0);
-            if (call.getType().equals(srcType)) {
+
+            // Short-circuit if no cast is required
+            if (call.getType().equals(srcType)
+                // However, do not elide casts to decimal types, they perform bounds checking
+                && srcType.getSqlTypeName() != SqlTypeName.DECIMAL) {
                 // No cast required, omit cast
                 return argValueList.get(0);
             }
@@ -1588,10 +1601,10 @@ private static class CastImplementor extends AbstractRexCallImplementor {
         private RelDataType nullifyType(JavaTypeFactory typeFactory,
             final RelDataType type, final boolean nullable) {
             if (type instanceof RelDataTypeFactoryImpl.JavaType) {
-                final Primitive primitive = Primitive.ofBox(
-                    ((RelDataTypeFactoryImpl.JavaType)type).getJavaClass());
-                if (primitive != null)
-                    return typeFactory.createJavaType(primitive.primitiveClass);
+                Class<?> javaCls = ((RelDataTypeFactoryImpl.JavaType)type).getJavaClass();
+                final Class<?> primitive = Primitive.unbox(javaCls);
+                if (primitive != javaCls)
+                    return typeFactory.createJavaType(primitive);
             }
             return typeFactory.createTypeWithNullability(type, nullable);
         }

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/RexToLixTranslator.java

@@ -52,6 +52,7 @@
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexLocalRef;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexNodeAndFieldIndex;
 import org.apache.calcite.rex.RexOver;
 import org.apache.calcite.rex.RexPatternFieldRef;
 import org.apache.calcite.rex.RexProgram;
@@ -1343,6 +1344,12 @@ private Result toInnerStorageType(final Result result, final Type storageType) {
         return new Result(isNullVariable, valVariable);
     }
 
+    /** */
+    @Override public Result visitNodeAndFieldIndex(
+        RexNodeAndFieldIndex nodeAndFieldIndex) {
+        throw new RuntimeException("cannot translate expression " + nodeAndFieldIndex);
+    }
+
     /** */
     Expression checkNull(Expression expr) {
         if (Primitive.flavor(expr.getType()) == Primitive.Flavor.PRIMITIVE)

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/exp/agg/GroupKey.java

@@ -18,7 +18,7 @@
 package org.apache.ignite.internal.processors.query.calcite.exec.exp.agg;
 
 import java.util.Objects;
-import org.apache.calcite.util.ImmutableBitSet;
+import com.google.common.collect.ImmutableList;
 import org.apache.ignite.binary.BinaryObjectException;
 import org.apache.ignite.binary.BinaryRawReader;
 import org.apache.ignite.binary.BinaryRawWriter;
@@ -120,7 +120,7 @@ public RowHandler<Row> rowHandler() {
      */
     public static <Row> @Nullable GroupKey<Row> of(Row r, RowHandler<Row> hnd, boolean allowNulls) {
         if (!allowNulls)
-            return of(r, hnd, ImmutableBitSet.of());
+            return of(r, hnd, ImmutableList.of());
 
         return new GroupKey<>(r, hnd);
     }
@@ -129,9 +129,9 @@ public RowHandler<Row> rowHandler() {
      * @return Group key for provided row. Can be {@code null} if key fields of row contain NULL values and nulls are
      * not allowed for these columns.
      */
-    public static <Row> @Nullable GroupKey<Row> of(Row r, RowHandler<Row> hnd, ImmutableBitSet allowNulls) {
+    public static <Row> @Nullable GroupKey<Row> of(Row r, RowHandler<Row> hnd, ImmutableList<Boolean> nullExclusions) {
         for (int i = 0; i < hnd.columnCount(r); i++) {
-            if (hnd.get(i, r) == null && !allowNulls.get(i))
+            if (hnd.get(i, r) == null && (i >= nullExclusions.size() || nullExclusions.get(i)))
                 return null;
         }