Merge branch 'apache:main' into main

Author: iwanttobepowerful

core/src/main/java/org/apache/calcite/rel/core/TableModify.java

@@ -55,7 +55,18 @@
  * <ul>
  * <li>For {@code INSERT}, those rows are the new values;
  * <li>for {@code DELETE}, the old values;
- * <li>for {@code UPDATE}, all old values plus updated new values.
+ * <li>for {@code UPDATE}, all old values plus updated new values;
+ * <li>for {@code MERGE}, the rows may contain fields for both {@code INSERT} and {@code UPDATE}
+ *     operations, depending on the clauses specified:
+ *     <ul>
+ *       <li>If only `WHEN MATCHED THEN UPDATE` is specified, the row contains all old values plus
+ *       updated new values (like {@code UPDATE}).</li>
+ *       <li>If only `WHEN NOT MATCHED THEN INSERT` is specified, the row contains new values to be
+ *       inserted (like {@code INSERT}).</li>
+ *       <li>If both `WHEN MATCHED THEN UPDATE` and `WHEN NOT MATCHED THEN INSERT` are specified,
+ *       the row contains: new values to be inserted, all old values, updated new values.
+ *     </ul>
+ *   </li>
  * </ul>
  */
 public abstract class TableModify extends SingleRel {

core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java

@@ -297,10 +297,13 @@ protected RelMdSize() {}
     switch (type.getSqlTypeName()) {
     case BOOLEAN:
     case TINYINT:
+    case UTINYINT:
       return 1d;
     case SMALLINT:
+    case USMALLINT:
       return 2d;
     case INTEGER:
+    case UINTEGER:
     case REAL:
     case DECIMAL:
     case DATE:
@@ -312,6 +315,7 @@ protected RelMdSize() {}
     case INTERVAL_MONTH:
       return 4d;
     case BIGINT:
+    case UBIGINT:
     case DOUBLE:
     case FLOAT: // sic
     case TIMESTAMP:
@@ -362,10 +366,13 @@ public double typeValueSize(RelDataType type, @Nullable Comparable value) {
     switch (type.getSqlTypeName()) {
     case BOOLEAN:
     case TINYINT:
+    case UTINYINT:
       return 1d;
     case SMALLINT:
+    case USMALLINT:
       return 2d;
     case INTEGER:
+    case UINTEGER:
     case REAL:
     case DATE:
     case TIME:
@@ -376,6 +383,7 @@ public double typeValueSize(RelDataType type, @Nullable Comparable value) {
     case INTERVAL_MONTH:
       return 4d;
     case BIGINT:
+    case UBIGINT:
     case FLOAT:  // sic
     case DOUBLE:
     case TIMESTAMP:

core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java

@@ -1121,9 +1121,6 @@ private static SqlIdentifier getSqlTargetTable(RelNode e) {
 
   /** Visits a TableModify; called by {@link #dispatch} via reflection. */
   public Result visit(TableModify modify) {
-    final Map<String, RelDataType> pairs = ImmutableMap.of();
-    final Context context = aliasContext(pairs, false);
-
     // Target Table Name
     final SqlIdentifier sqlTargetTable = getSqlTargetTable(modify);
 
@@ -1142,6 +1139,10 @@ public Result visit(TableModify modify) {
     }
     case UPDATE: {
       final Result input = visitInput(modify, 0);
+      // SELECT statement has two parts: columns from the target table (old values) and
+      // expressions for the UPDATE. See the TableModify documentation for details.
+      final SqlSelect select = input.asSelect();
+      final Context context = selectListContext(select.getSelectList(), false);
 
       final SqlUpdate sqlUpdate =
           new SqlUpdate(POS, sqlTargetTable,
@@ -1151,8 +1152,7 @@ public Result visit(TableModify modify) {
               exprList(context,
                   requireNonNull(modify.getSourceExpressionList(),
                       () -> "modify.getSourceExpressionList() is null for " + modify)),
-              ((SqlSelect) input.node).getWhere(), input.asSelect(),
-              null);
+              select.getWhere(), select, null);
 
       return result(sqlUpdate, input.clauses, modify, null);
     }
@@ -1172,7 +1172,7 @@ public Result visit(TableModify modify) {
       // `WHEN NOT MATCHED THEN INSERT` clauses, the selectList consists of three parts:
       // the insert expression, the target table reference, and the update expression.
       // When querying with the `WHEN MATCHED THEN UPDATE` clause, the selectList will not
-      // include the update expression.
+      // include the insert expression.
       // However, when querying with the `WHEN NOT MATCHED THEN INSERT` clause,
       // the expression list will only contain the insert expression.
       final SqlNodeList selectList = SqlUtil.stripListAs(select.getSelectList());

core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java

@@ -1633,6 +1633,10 @@ private static int computeFieldCount(
     return x;
   }
 
+  public Context selectListContext(SqlNodeList sqlNodeList, boolean aliasRef) {
+    return new SelectListContext(dialect, sqlNodeList.size(), aliasRef, sqlNodeList);
+  }
+
   public Context aliasContext(Map<String, RelDataType> aliases,
       boolean qualified) {
     return new AliasContext(dialect, aliases, qualified);
@@ -1810,6 +1814,80 @@ private boolean isWindowTableFunctionRex(RexNode rex) {
     };
   }
 
+  /**
+   * A context that uses a select list.
+   */
+  final class SelectListContext extends BaseContext {
+    private final boolean aliasRef;
+    private final SqlNodeList selectList;
+
+    /**
+     * Creates a SelectListContext.
+     *
+     * @param dialect    SQL dialect.
+     * @param fieldCount Number of fields.
+     * @param aliasRef   If true, and a select-list item at a given ordinal has an alias
+     *                   (e.g. {@code SUM(x) AS sx}), then a call to {@code field(ordinal)}
+     *                   will return the alias ({@code sx}). If false, it will return the
+     *                   full expression ({@code SUM(x)}).
+     * @param selectList The list of expressions in a SELECT clause.
+     */
+    SelectListContext(
+        SqlDialect dialect, int fieldCount, boolean aliasRef, SqlNodeList selectList) {
+      super(dialect, fieldCount);
+      this.aliasRef = aliasRef;
+      this.selectList = selectList;
+    }
+
+    @Override public SqlNode field(int ordinal) {
+      final SqlNode selectItem = selectList.get(ordinal);
+      switch (selectItem.getKind()) {
+      case AS:
+        final SqlCall asCall = (SqlCall) selectItem;
+        SqlNode alias = asCall.operand(1);
+        if (aliasRef && !SqlUtil.isGeneratedAlias(((SqlIdentifier) alias).getSimple())) {
+          // For BigQuery, given the query
+          //   SELECT SUM(x) AS x FROM t HAVING(SUM(t.x) > 0)
+          // we can generate
+          //   SELECT SUM(x) AS x FROM t HAVING(x > 0)
+          // because 'x' in HAVING resolves to the 'AS x' not 't.x'.
+          return alias;
+        }
+        return asCall.operand(0);
+      default:
+        break;
+      }
+      return selectItem;
+    }
+
+    @Override public SqlNode orderField(int ordinal) {
+      // If the field expression is an unqualified column identifier
+      // and matches a different alias, use an ordinal.
+      // For example, given
+      //    SELECT deptno AS empno, empno AS x FROM emp ORDER BY emp.empno
+      // we generate
+      //    SELECT deptno AS empno, empno AS x FROM emp ORDER BY 2
+      // "ORDER BY empno" would give incorrect result;
+      // "ORDER BY x" is acceptable but is not preferred.
+      final SqlNode node = super.orderField(ordinal);
+      if (node instanceof SqlIdentifier
+          && ((SqlIdentifier) node).isSimple()) {
+        final String name = ((SqlIdentifier) node).getSimple();
+        for (Ord<SqlNode> selectItem : Ord.zip(selectList)) {
+          if (selectItem.i != ordinal) {
+            final @Nullable String alias =
+                SqlValidatorUtil.alias(selectItem.e);
+            if (name.equalsIgnoreCase(alias) && dialect.getConformance().isSortByAlias()) {
+              return SqlLiteral.createExactNumeric(
+                  Integer.toString(ordinal + 1), SqlParserPos.ZERO);
+            }
+          }
+        }
+      }
+      return node;
+    }
+  }
+
   /** Result of implementing a node. */
   public class Result {
     final SqlNode node;
@@ -1907,7 +1985,7 @@ private Builder builder(RelNode rel, Set<Clause> clauses) {
       if (!selectList.equals(SqlNodeList.SINGLETON_STAR)) {
         final boolean aliasRef = expectedClauses.contains(Clause.HAVING)
             && dialect.getConformance().isHavingAlias();
-        newContext = new SelectListContext(dialect, selectList.size(), aliasRef, selectList);
+        newContext = selectListContext(selectList, aliasRef);
       } else {
         boolean qualified =
             !dialect.hasImplicitTableAlias() || aliases.size() > 1;
@@ -2295,69 +2373,6 @@ Result withExpectedClauses(boolean ignoreClauses,
           : new Result(node, clauses, neededAlias, neededType, aliases, anon,
               ignoreClauses, ImmutableSet.copyOf(expectedClauses), expectedRel);
     }
-
-    /**
-     * A context that uses a select list.
-     */
-    private final class SelectListContext extends BaseContext {
-      private final boolean aliasRef;
-      private final SqlNodeList selectList;
-
-      private SelectListContext(
-          SqlDialect dialect, int fieldCount, boolean aliasRef, SqlNodeList selectList) {
-        super(dialect, fieldCount);
-        this.aliasRef = aliasRef;
-        this.selectList = selectList;
-      }
-
-      @Override public SqlNode field(int ordinal) {
-        final SqlNode selectItem = selectList.get(ordinal);
-        switch (selectItem.getKind()) {
-        case AS:
-          final SqlCall asCall = (SqlCall) selectItem;
-          SqlNode alias = asCall.operand(1);
-          if (aliasRef && !SqlUtil.isGeneratedAlias(((SqlIdentifier) alias).getSimple())) {
-            // For BigQuery, given the query
-            //   SELECT SUM(x) AS x FROM t HAVING(SUM(t.x) > 0)
-            // we can generate
-            //   SELECT SUM(x) AS x FROM t HAVING(x > 0)
-            // because 'x' in HAVING resolves to the 'AS x' not 't.x'.
-            return alias;
-          }
-          return asCall.operand(0);
-        default:
-          break;
-        }
-        return selectItem;
-      }
-
-      @Override public SqlNode orderField(int ordinal) {
-        // If the field expression is an unqualified column identifier
-        // and matches a different alias, use an ordinal.
-        // For example, given
-        //    SELECT deptno AS empno, empno AS x FROM emp ORDER BY emp.empno
-        // we generate
-        //    SELECT deptno AS empno, empno AS x FROM emp ORDER BY 2
-        // "ORDER BY empno" would give incorrect result;
-        // "ORDER BY x" is acceptable but is not preferred.
-        final SqlNode node = super.orderField(ordinal);
-        if (node instanceof SqlIdentifier
-            && ((SqlIdentifier) node).isSimple()) {
-          final String name = ((SqlIdentifier) node).getSimple();
-          for (Ord<SqlNode> selectItem : Ord.zip(selectList)) {
-            if (selectItem.i != ordinal) {
-              final @Nullable String alias =
-                  SqlValidatorUtil.alias(selectItem.e);
-              if (name.equalsIgnoreCase(alias) && dialect.getConformance().isSortByAlias()) {
-                return SqlLiteral.createExactNumeric(
-                    Integer.toString(ordinal + 1), SqlParserPos.ZERO);
-              }
-            }
-          }
-        }
-        return node;
-      }
-    }
   }
 
   /** Builder. */

core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java

@@ -149,6 +149,7 @@ static ImmutableSortedSet<TimeUnitRange> extractTimeUnits(RexNode e) {
   @VisibleForTesting
   public static RexNode replaceTimeUnits(RexBuilder rexBuilder, RexNode e,
       String timeZone) {
+    e = RexUtil.expandSearch(rexBuilder, null, e);
     ImmutableSortedSet<TimeUnitRange> timeUnits = extractTimeUnits(e);
     if (!timeUnits.contains(TimeUnitRange.YEAR)) {
       // Case when we have FLOOR or CEIL but no extract on YEAR.

core/src/main/java/org/apache/calcite/rex/RexSimplify.java

@@ -3175,13 +3175,28 @@ static class SargCollector {
       this.negate = negate;
     }
 
+    /**
+     * Accepts an expression and converts it to a Sarg if possible.
+     *
+     * @param term the expression to convert
+     * @param newTerms the list holding the result of the conversion or the
+     *                 original term if it cannot be converted
+     */
     private void accept(RexNode term, List<RexNode> newTerms) {
       if (!accept_(term, newTerms)) {
         newTerms.add(term);
       }
       newTermsCount = newTerms.size();
     }
 
+    /**
+     * Accepts an expression and converts it to a Sarg if possible.
+     * Only certain kinds of expressions can be converted to Sargs.
+     *
+     * @param e the expression to convert
+     * @param newTerms the list to which the Sarg will be added if the expression is accepted
+     * @return true if the expression can be converted to a Sarg, false otherwise
+     */
     private boolean accept_(RexNode e, List<RexNode> newTerms) {
       switch (e.getKind()) {
       case LESS_THAN:
@@ -3204,31 +3219,25 @@ private boolean accept_(RexNode e, List<RexNode> newTerms) {
       }
     }
 
+    /**
+     * Accepts two operands from a binary comparison operator and converts them to a Sarg if
+     * possible. Only comparisons between a literal and a deterministic expression can be converted.
+     * Simplifications with non-deterministic expressions are generally avoided to ensure consistent
+     * results.
+     *
+     * @param left the left operand of the comparison
+     * @param right the right operand of the comparison
+     * @param kind the kind of comparison operator
+     * @param newTerms the list to which the Sarg will be added if accepted
+     * @return true if the operands can be converted to a Sarg, false otherwise
+     */
     private boolean accept2(RexNode left, RexNode right, SqlKind kind,
         List<RexNode> newTerms) {
-      switch (left.getKind()) {
-      case INPUT_REF:
-      case FIELD_ACCESS:
-      case CAST:
-        switch (right.getKind()) {
-        case LITERAL:
-          return accept2b(left, kind, (RexLiteral) right, newTerms);
-        default:
-          break;
-        }
-        return false;
-      case LITERAL:
-        switch (right.getKind()) {
-        case INPUT_REF:
-        case FIELD_ACCESS:
-        case CAST:
-          return accept2b(right, kind.reverse(), (RexLiteral) left, newTerms);
-        default:
-          break;
-        }
-        return false;
-      default:
-        break;
+      if (right.isA(SqlKind.LITERAL) && RexUtil.isDeterministic(left)) {
+        return accept2b(left, kind, (RexLiteral) right, newTerms);
+      }
+      if (left.isA(SqlKind.LITERAL) && RexUtil.isDeterministic(right)) {
+        return accept2b(right, kind.reverse(), (RexLiteral) left, newTerms);
       }
       return false;
     }
@@ -3238,7 +3247,14 @@ private static <E> E addFluent(List<? super E> list, E e) {
       return e;
     }
 
-    // always returns true
+    /**
+     * Accepts an operand from a null predicate and converts it to a Sarg.
+     *
+     * @param e the operand of the null predicate
+     * @param kind the kind of the null predicate
+     * @param newTerms the list to which the Sarg is added
+     * @return true since the operand is always converted to a Sarg
+     */
     private boolean accept1(RexNode e, SqlKind kind, List<RexNode> newTerms) {
       final RexSargBuilder b =
           map.computeIfAbsent(e, e2 ->
@@ -3256,6 +3272,17 @@ private boolean accept1(RexNode e, SqlKind kind, List<RexNode> newTerms) {
       }
     }
 
+    /**
+     * Accepts two operands from a binary comparison operator and converts them to a Sarg when the
+     * literal is not null. The conversion depends on the kind of comparison operator and only
+     * certain operators are supported.
+     *
+     * @param e any kind of deterministic expression
+     * @param kind the kind of comparison operator
+     * @param literal the literal operand of the comparison
+     * @param newTerms the list to which the Sarg is added if accepted
+     * @return false if the literal operand is null, true otherwise
+     */
     private boolean accept2b(RexNode e, SqlKind kind,
         RexLiteral literal, List<RexNode> newTerms) {
       if (literal.getValue() == null) {