Reinstate consistency checks

Signed-off-by: Mihai Budiu <[email protected]>
apache · Jan 9, 2025 · c6eee80 · c6eee80
1 parent 8f10f82
commit c6eee80
Show file tree

Hide file tree

Showing 3 changed files with 59 additions and 5 deletions.
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
@@ -94,6 +94,7 @@
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.type.MultisetSqlType;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.tools.RelBuilderFactory;
 import org.apache.calcite.util.ImmutableBitSet;
@@ -2222,6 +2223,45 @@ public static boolean eq(
     return litmus.succeed();
   }
 
+  /**
+   * Returns whether two types are equal, perhaps ignoring nullability.
+   *
+   * @param ignoreNullability If true the types must be equal ignoring the (top-level) nullability.
+   * @param desc1 Description of first type
+   * @param type1 First type
+   * @param desc2 Description of second type
+   * @param type2 Second type
+   * @param litmus What to do if an error is detected (types are not equal)
+   * @return Whether the types are equal
+   */
+  public static boolean eqUpToNullability(
+      boolean ignoreNullability,
+      final String desc1,
+      RelDataType type1,
+      final String desc2,
+      RelDataType type2,
+      Litmus litmus) {
+    // if any one of the types is ANY return true
+    if (type1.getSqlTypeName() == SqlTypeName.ANY
+        || type2.getSqlTypeName() == SqlTypeName.ANY) {
+      return litmus.succeed();
+    }
+
+    boolean success;
+    if (ignoreNullability) {
+      success = SqlTypeUtil.equalSansNullability(type1, type2);
+    } else {
+      success = type1.equals(type2);
+    }
+
+    if (!success) {
+      return litmus.fail("type mismatch:\n{}:\n{}\n{}:\n{}",
+          desc1, type1.getFullTypeString(),
+          desc2, type2.getFullTypeString());
+    }
+    return litmus.succeed();
+  }
+
   /**
    * Returns whether two types are equal using
    * {@link #areRowTypesEqual(RelDataType, RelDataType, boolean)}. Both types

diff --git a/core/src/main/java/org/apache/calcite/rex/RexChecker.java b/core/src/main/java/org/apache/calcite/rex/RexChecker.java
@@ -127,6 +127,14 @@ public int getFailureCount() {
           index, inputTypeList.size() - 1);
     }
     // Type of field and type of result can differ in nullability.  See [CALCITE-6764]
+    if (!ref.getType().isStruct()
+        && !RelOptUtil.eqUpToNullability(
+            ref.getType().isNullable(),
+            "ref", ref.getType(), "input",
+        inputTypeList.get(index), litmus)) {
+      ++failCount;
+      return litmus.fail(null);
+    }
     return litmus.succeed();
   }
 
@@ -156,6 +164,16 @@ public int getFailureCount() {
       return litmus.fail(null);
     }
     // Type of field may not match type of field access - they may differ in nullability
+    final RelDataTypeField typeField = refType.getFieldList().get(index);
+    if (!RelOptUtil.eqUpToNullability(
+        refType.isNullable(),
+        "type1",
+        typeField.getType(),
+        "type2",
+        fieldAccess.getType(), litmus)) {
+      ++failCount;
+      return litmus.fail(null);
+    }
     return litmus.succeed();
   }
 

diff --git a/core/src/main/java/org/apache/calcite/rex/RexFieldAccess.java b/core/src/main/java/org/apache/calcite/rex/RexFieldAccess.java
@@ -63,11 +63,7 @@ public class RexFieldAccess extends RexNode {
   RexFieldAccess(
       RexNode expr,
       RelDataTypeField field) {
-    checkValid(expr, field);
-    this.expr = expr;
-    this.field = field;
-    this.digest = expr + "." + field.getName();
-    this.type = field.getType();
+    this(expr, field, field.getType());
   }
 
   RexFieldAccess(