diff --git a/babel/src/test/java/org/apache/calcite/test/BabelQuidemTest.java b/babel/src/test/java/org/apache/calcite/test/BabelQuidemTest.java
index 54058f67cec..623f52bee8d 100644
--- a/babel/src/test/java/org/apache/calcite/test/BabelQuidemTest.java
+++ b/babel/src/test/java/org/apache/calcite/test/BabelQuidemTest.java
@@ -120,6 +120,7 @@ public static void main(String[] args) throws Exception {
                   ConnectionFactories.addType("TIMESTAMP", typeFactory ->
                       typeFactory.createSqlType(
                           SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)))
+              .with(CalciteConnectionProperty.TIME_ZONE, "UTC")
               .connect();
         case "scott-postgresql":
           return CalciteAssert.that()
diff --git a/babel/src/test/resources/sql/big-query.iq b/babel/src/test/resources/sql/big-query.iq
index 5ffa0bdf66d..834bd65dd8d 100755
--- a/babel/src/test/resources/sql/big-query.iq
+++ b/babel/src/test/resources/sql/big-query.iq
@@ -410,14 +410,12 @@ SELECT
 # In the following example, EXTRACT returns values corresponding to
 # different date parts from a column of dates near the end of the
 # year.
-
-!if (false) {
 SELECT
   d,
   EXTRACT(ISOYEAR FROM d) AS isoyear,
-  EXTRACT(ISOWEEK FROM d) AS isoweek,
-  EXTRACT(YEAR FROM d) AS year,
-  EXTRACT(WEEK FROM d) AS week
+  EXTRACT(ISOWEEK FROM d) as isoweek,
+  EXTRACT(WEEK(TUESDAY) FROM d) AS week_tues,
+  EXTRACT(YEAR FROM d) AS year
 FROM UNNEST(
   ARRAY [DATE '2015-12-23',
          DATE '2015-12-24',
@@ -438,48 +436,62 @@ FROM UNNEST(
          DATE '2016-01-08',
          DATE '2016-01-09']) AS d
 ORDER BY d;
-+------------+---------+---------+------+------+
-| date       | isoyear | isoweek | year | week |
-+------------+---------+---------+------+------+
-| 2015-12-23 | 2015    | 52      | 2015 | 51   |
-| 2015-12-24 | 2015    | 52      | 2015 | 51   |
-| 2015-12-25 | 2015    | 52      | 2015 | 51   |
-| 2015-12-26 | 2015    | 52      | 2015 | 51   |
-| 2015-12-27 | 2015    | 52      | 2015 | 52   |
-| 2015-12-28 | 2015    | 53      | 2015 | 52   |
-| 2015-12-29 | 2015    | 53      | 2015 | 52   |
-| 2015-12-30 | 2015    | 53      | 2015 | 52   |
-| 2015-12-31 | 2015    | 53      | 2015 | 52   |
-| 2016-01-01 | 2015    | 53      | 2016 | 0    |
-| 2016-01-02 | 2015    | 53      | 2016 | 0    |
-| 2016-01-03 | 2015    | 53      | 2016 | 1    |
-| 2016-01-04 | 2016    | 1       | 2016 | 1    |
-| 2016-01-05 | 2016    | 1       | 2016 | 1    |
-| 2016-01-06 | 2016    | 1       | 2016 | 1    |
-| 2016-01-07 | 2016    | 1       | 2016 | 1    |
-| 2016-01-08 | 2016    | 1       | 2016 | 1    |
-| 2016-01-09 | 2016    | 1       | 2016 | 1    |
-+------------+---------+---------+------+------+
++------------+---------+---------+-----------+------+
+| d          | isoyear | isoweek | week_tues | year |
++------------+---------+---------+-----------+------+
+| 2015-12-23 |    2015 |      52 |        51 | 2015 |
+| 2015-12-24 |    2015 |      52 |        51 | 2015 |
+| 2015-12-25 |    2015 |      52 |        51 | 2015 |
+| 2015-12-26 |    2015 |      52 |        51 | 2015 |
+| 2015-12-27 |    2015 |      52 |        51 | 2015 |
+| 2015-12-28 |    2015 |      53 |        51 | 2015 |
+| 2015-12-29 |    2015 |      53 |        52 | 2015 |
+| 2015-12-30 |    2015 |      53 |        52 | 2015 |
+| 2015-12-31 |    2015 |      53 |        52 | 2015 |
+| 2016-01-01 |    2015 |      53 |         0 | 2016 |
+| 2016-01-02 |    2015 |      53 |         0 | 2016 |
+| 2016-01-03 |    2015 |      53 |         0 | 2016 |
+| 2016-01-04 |    2016 |       1 |         0 | 2016 |
+| 2016-01-05 |    2016 |       1 |         1 | 2016 |
+| 2016-01-06 |    2016 |       1 |         1 | 2016 |
+| 2016-01-07 |    2016 |       1 |         1 | 2016 |
+| 2016-01-08 |    2016 |       1 |         1 | 2016 |
+| 2016-01-09 |    2016 |       1 |         1 | 2016 |
++------------+---------+---------+-----------+------+
+(18 rows)
+
 !ok
-!}
+
 
 # In the following example, date_expression falls on a Sunday. EXTRACT
 # calculates the first column using weeks that begin on Sunday, and it
 # calculates the second column using weeks that begin on Monday.
 
-!if (false) {
 WITH t AS (SELECT DATE('2017-11-05') AS d)
 SELECT
   d,
+  EXTRACT(ISOWEEK FROM d) AS isoweek,
   EXTRACT(WEEK(SUNDAY) FROM d) AS week_sunday,
   EXTRACT(WEEK(MONDAY) FROM d) AS week_monday FROM t;
-+------------+-------------+-------------+
-| date       | week_sunday | week_monday |
-+------------+-------------+-------------+
-| 2017-11-05 | 45          | 44          |
-+------------+-------------+-------------+
++------------+---------+-------------+-------------+
+| d          | isoweek | week_sunday | week_monday |
++------------+---------+-------------+-------------+
+| 2017-11-05 |      44 |          45 |          44 |
++------------+---------+-------------+-------------+
+(1 row)
+
+!ok
+
+SELECT EXTRACT(DAYOFWEEK FROM DATE '2008-12-25') as dow,
+    EXTRACT(DAYOFYEAR FROM DATE '2008-12-25') as doy;
++-----+-----+
+| dow | doy |
++-----+-----+
+|   5 | 360 |
++-----+-----+
+(1 row)
+
 !ok
-!}
 
 # In the following example, EXTRACT returns a value corresponding to
 # the HOUR time part.
@@ -2708,6 +2720,18 @@ SELECT TIMESTAMP(DATE "2008-12-25") AS timestamp_date;
 
 !ok
 
+# This tests the no-op TIMESTAMP and DATETIME functions.
+select TIMESTAMP(TIMESTAMP "2008-01-01 01:03:05") as ts,
+       DATETIME(DATETIME "2008-01-01 01:03:05") as dt;
++---------------------+---------------------+
+| ts                  | dt                  |
++---------------------+---------------------+
+| 2008-01-01 01:03:05 | 2008-01-01 01:03:05 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
 # All these timestamps should be equal.
 # This tests the BQ timestamp literal string formatter
 # (optional 'T', optional leading zeros, optional offset with conversion).
@@ -3428,7 +3452,8 @@ SELECT
 (1 row)
 
 !ok
-
+# Bug.CALCITE_2539_FIXED
+!if (false) {
 #####################################################################
 # DATE_DIFF
 #
@@ -3739,6 +3764,8 @@ SELECT TIMESTAMP_DIFF(TIMESTAMP '2008-12-25', TIMESTAMP '2008-09-25', `quarter`)
 (1 row)
 
 !ok
+
+!}
 #####################################################################
 # DATE_TRUNC
 #
diff --git a/core/src/main/codegen/templates/Parser.jj b/core/src/main/codegen/templates/Parser.jj
index 93fda1d8a05..d29de207978 100644
--- a/core/src/main/codegen/templates/Parser.jj
+++ b/core/src/main/codegen/templates/Parser.jj
@@ -6127,6 +6127,15 @@ SqlTypeNameSpec DateTimeTypeName() :
         typeName = SqlTypeName.DATE;
         return new SqlBasicTypeNameSpec(typeName, getPos());
     }
+|
+    // DATETIME is the BigQuery-specific name for ISO SQL's TIMESTAMP type.
+    // In order to support this, the schema UDT map must be properly configued.
+    // See the BigQuery Quidem tests in the babel component for an example.
+    <DATETIME> {
+        s = span();
+        return new SqlUserDefinedTypeNameSpec(
+            unquotedIdentifier(), precision, s.end(this));
+    }
 |
     LOOKAHEAD(2)
     <TIME> { s = span(); }
@@ -6140,7 +6149,12 @@ SqlTypeNameSpec DateTimeTypeName() :
     precision = PrecisionOpt()
     typeName = TimeZoneOpt(false)
     {
-        return new SqlBasicTypeNameSpec(typeName, precision, s.end(this));
+        // Like DATETIME above, TIMESTAMP may have a different meaning for
+        // certain SQL dialects (namely, BigQuery). Unlike DATETIME, TIMESTAMP
+        // types names have default standard types that will be used in the
+        // absence of a UDT mapping.
+        return new SqlUserDefinedTypeNameSpec(
+            typeName.getSpaceName(), precision, s.end(this));
     }
 }
 
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
index 2ff47db2194..017ed869d4c 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
@@ -3074,6 +3074,10 @@ private static class ExtractImplementor extends AbstractRexCallImplementor {
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
         final RexCall call, final List<Expression> argValueList) {
+      if (argValueList.get(0).getType() == String.class) {
+        return Expressions.call(BuiltInMethod.CUSTOM_DATE_EXTRACT.method,
+            translator.getRoot(), argValueList.get(0), argValueList.get(1));
+      }
       final TimeUnitRange timeUnitRange =
           (TimeUnitRange) translator.getLiteralValue(argValueList.get(0));
       final TimeUnit unit = requireNonNull(timeUnitRange, "timeUnitRange").startUnit;
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactory.java b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactory.java
index 1f9d1a487b9..53a2cc4b8f9 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactory.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactory.java
@@ -32,7 +32,7 @@ MetaColumn createColumn(Table table, String tableCat, String tableSchem,
       String tableName, String columnName, int dataType, String typeName,
       Integer columnSize, @Nullable Integer decimalDigits, int numPrecRadix,
       int nullable, Integer charOctetLength, int ordinalPosition,
-      String isNullable);
+      String isNullable, String isAutoincrement, String isGeneratedcolumn);
 
   /** Returns the list of expected column names.
    *
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactoryImpl.java b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactoryImpl.java
index be320626cf1..80b920391fe 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactoryImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactoryImpl.java
@@ -46,7 +46,9 @@ protected CalciteMetaColumnFactoryImpl() {}
       int nullable,
       Integer charOctetLength,
       int ordinalPosition,
-      String isNullable) {
+      String isNullable,
+      String isAutoincrement,
+      String isGeneratedcolumn) {
     return new MetaColumn(
         tableCat,
         tableSchem,
@@ -60,7 +62,9 @@ protected CalciteMetaColumnFactoryImpl() {}
         nullable,
         charOctetLength,
         ordinalPosition,
-        isNullable);
+        isNullable,
+        isAutoincrement,
+        isGeneratedcolumn);
   }
 
   @Override public Class<? extends MetaColumn> getMetaColumnClass() {
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
index 82be2738778..821ad28d359 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
@@ -566,7 +566,11 @@ public Enumerable<MetaColumn> columns(final MetaTable table_) {
                   : DatabaseMetaData.columnNoNulls,
               precision,
               field.getIndex() + 1,
-              field.getType().isNullable() ? "YES" : "NO");
+              field.getType().isNullable() ? "YES" : "NO",
+              "NO",
+              field.getType().getSqlTypeName() == SqlTypeName.MEASURE
+                  ? "YES"
+                  : "NO");
         });
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java b/core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java
index aa6ea524ac5..62a4d5aa0dd 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java
@@ -468,9 +468,8 @@ public Aggregate.AggCallBinding createBinding(
     final RelDataTypeFactory typeFactory =
         aggregateRelBase.getCluster().getTypeFactory();
 
-    if (aggFunction.getKind() == SqlKind.PERCENTILE_DISC
-        || aggFunction.getKind() == SqlKind.PERCENTILE_CONT) {
-      assert collation.getKeys().size() == 1;
+    if (this.argList.size() == 1 && (aggFunction.getKind() == SqlKind.PERCENTILE_DISC
+        || aggFunction.getKind() == SqlKind.PERCENTILE_CONT)) {
       return new Aggregate.PercentileDiscAggCallBinding(typeFactory,
           aggFunction, SqlTypeUtil.projectTypes(rowType, argList),
           SqlTypeUtil.projectTypes(rowType, collation.getKeys()).get(0),
diff --git a/core/src/main/java/org/apache/calcite/rel/externalize/RelJson.java b/core/src/main/java/org/apache/calcite/rel/externalize/RelJson.java
index 3f7cbbca973..130ab18462e 100644
--- a/core/src/main/java/org/apache/calcite/rel/externalize/RelJson.java
+++ b/core/src/main/java/org/apache/calcite/rel/externalize/RelJson.java
@@ -630,6 +630,7 @@ public Object toJson(RexNode node) {
         }
         map.put("operands", list);
         switch (node.getKind()) {
+        case TIMESTAMP_DIFF:
         case MINUS:
         case CAST:
         case SAFE_CAST:
diff --git a/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
index 9950674ea15..ad4e02f7210 100644
--- a/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
+++ b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
@@ -16,7 +16,6 @@
  */
 package org.apache.calcite.rel.rel2sql;
 
-import org.apache.calcite.config.CalciteSystemProperty;
 import org.apache.calcite.linq4j.Ord;
 import org.apache.calcite.linq4j.tree.Expressions;
 import org.apache.calcite.plan.RelOptUtil;
@@ -94,7 +93,6 @@
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.RangeSets;
 import org.apache.calcite.util.Sarg;
@@ -571,6 +569,8 @@ private boolean requiresAlias(SqlNode node) {
     case JOIN:
     case EXPLICIT_TABLE:
       return false;
+    case SELECT:
+      return node instanceof SqlSelect; // TODO workaround asIs hack
     default:
       return true;
     }
@@ -618,17 +618,9 @@ protected Context(SqlDialect dialect, int fieldCount, boolean ignoreCast) {
      */
     public SqlNode orderField(int ordinal) {
       final SqlNode node = field(ordinal);
-      if (node instanceof SqlNumericLiteral
-          && dialect.getConformance().isSortByOrdinal()) {
-        // An integer literal will be wrongly interpreted as a field ordinal.
-        // Convert it to a character literal, which will have the same effect.
-        final String strValue = ((SqlNumericLiteral) node).toValue();
-        return SqlLiteral.createCharString(strValue, node.getParserPosition());
-      }
-      if (node instanceof SqlCall
-          && dialect.getConformance().isSortByOrdinal()) {
-        // If the field is expression and sort by ordinal is set in dialect,
-        // convert it to ordinal.
+      if (!(node instanceof SqlIdentifier) && dialect.getConformance().shouldSortByOrdinal()) {
+        // If the dialect allows sorting by ordinal, and the field is anything but a named field
+        // reference, prefer to sort by ordinal instead.
         return SqlLiteral.createExactNumeric(
             Integer.toString(ordinal + 1), SqlParserPos.ZERO);
       }
@@ -1431,20 +1423,8 @@ public static SqlNode toSql(RexLiteral literal) {
             () -> "literal " + literal
                 + " has null SqlTypeFamily, and is SqlTypeName is " + typeName);
     switch (family) {
-    case CHARACTER: {
-      final NlsString value = literal.getValueAs(NlsString.class);
-      if (value != null) {
-        final String defaultCharset = CalciteSystemProperty.DEFAULT_CHARSET.value();
-        final String charsetName = value.getCharsetName();
-        if (!defaultCharset.equals(charsetName)) {
-          // Set the charset only if it is not the same as the default charset
-          return SqlLiteral.createCharString(
-              castNonNull(value).getValue(), charsetName, POS);
-        }
-      }
-      // Create a string without specifying a charset
+    case CHARACTER:
       return SqlLiteral.createCharString((String) castNonNull(literal.getValue2()), POS);
-    }
     case NUMERIC:
     case EXACT_NUMERIC: {
       if (SqlTypeName.APPROX_TYPES.contains(typeName)) {
diff --git a/core/src/main/java/org/apache/calcite/rel/type/TimeFrameSet.java b/core/src/main/java/org/apache/calcite/rel/type/TimeFrameSet.java
index 07869b8504a..b39096c9aeb 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/TimeFrameSet.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/TimeFrameSet.java
@@ -287,6 +287,41 @@ public long diffTimestamp(long timestamp, long timestamp2, TimeFrame frame) {
     return timestamp;
   }
 
+  /** For ISOWEEK and WEEK(WEEKDAY), EXTRACT can be rewritten
+   * as the composition of DATE_DIFF and DATE_TRUNC. DAYOFWEEK and DAYOFYEAR
+   * are just translated to DOW and DOY respectively. */
+  public long extractDate(int date, TimeFrame timeFrame) {
+    TimeUnitRange timeUnitRange;
+    int offset = 0;
+    // Date will be truncated to either ISOYEAR or YEAR depending on time frame.
+    switch (timeFrame.name()) {
+    case "DAYOFWEEK":
+      return DateTimeUtils.unixDateExtract(TimeUnitRange.DOW, date);
+    case "DAYOFYEAR":
+      return DateTimeUtils.unixDateExtract(TimeUnitRange.DOY, date);
+    case "ISOWEEK":
+      timeUnitRange = TimeUnitRange.ISOYEAR;
+      offset += 1;
+      break;
+    default:
+      if (TimeFrames.WEEK_FRAME_NAMES.contains(timeFrame.name())) {
+        timeUnitRange = TimeUnitRange.YEAR;
+      } else {
+        throw new IllegalArgumentException("Unsupported frame for EXTRACT: " + timeFrame.name());
+      }
+      break;
+    }
+    // Date is truncated first to year/isoyear and then to the provided time frame.
+    int y0 = (int) DateTimeUtils.unixDateFloor(timeUnitRange, date);
+    int date2 = floorDate(y0, timeFrame);
+
+    // For WEEK(WEEKDAY), if year starts on WEEKDAY then offset of +1 is required.
+    if (date2 == y0 && timeUnitRange != TimeUnitRange.ISOYEAR) {
+      offset += 1;
+    }
+    return (long) diffDate(date2, date, timeFrame) + offset;
+  }
+
   /** Builds a collection of time frames. */
   public interface Builder {
     /** Creates a {@code TimeFrameSet}. */
diff --git a/core/src/main/java/org/apache/calcite/rel/type/TimeFrames.java b/core/src/main/java/org/apache/calcite/rel/type/TimeFrames.java
index f69e66f3c6e..d22ac7d971f 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/TimeFrames.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/TimeFrames.java
@@ -117,6 +117,8 @@ private static BuilderImpl addCore(BuilderImpl b) {
 
     b.addQuotient(TimeUnit.DOY, TimeUnit.DAY, TimeUnit.YEAR);
     b.addQuotient(TimeUnit.DOW, TimeUnit.DAY, TimeUnit.WEEK);
+    b.addQuotient("DAYOFYEAR", TimeUnit.DAY.name(), TimeUnit.YEAR.name());
+    b.addQuotient("DAYOFWEEK", TimeUnit.DAY.name(), TimeUnit.WEEK.name());
     b.addQuotient(TimeUnit.ISODOW.name(), TimeUnit.DAY.name(), "ISOWEEK");
 
     b.addRollup(TimeUnit.DAY, TimeUnit.MONTH);
diff --git a/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
index 8fbdfb11a48..818794f9581 100644
--- a/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -87,6 +87,7 @@
 import java.text.Normalizer;
 import java.text.ParsePosition;
 import java.text.SimpleDateFormat;
+import java.time.DateTimeException;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -153,6 +154,8 @@ public class SqlFunctions {
   private static final DecimalFormat DOUBLE_FORMAT =
       NumberUtil.decimalFormat("0.0E0");
 
+  private static final ZoneId UTC_ZONE_ID = ZoneId.of("UTC");
+
   private static final TimeZone LOCAL_TZ = TimeZone.getDefault();
 
   private static final DateTimeFormatter ROOT_DAY_FORMAT =
@@ -212,12 +215,11 @@ public class SqlFunctions {
   private static final ByteString SINGLE_SPACE_BYTE_STRING =
       ByteString.of("20", 16);
 
-  // Date formatter for BigQuery's timestamp literals:
-  // https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#timestamp_literals
-  private static final DateTimeFormatter BIG_QUERY_TIMESTAMP_LITERAL_FORMATTER =
+  /** Date formatter used to *parse* timestamp literals. */
+  private static final DateTimeFormatter TIMESTAMP_LITERAL_FORMATTER =
       new DateTimeFormatterBuilder()
-          // Unlike ISO 8601, BQ only supports years between 1 - 9999,
-          // but can support single-digit month and day parts.
+          // Support 4-digit years between 0001 - 9999.
+          // Month and day parts may be single-digit.
           .appendValue(ChronoField.YEAR, 4)
           .appendLiteral('-')
           .appendValue(ChronoField.MONTH_OF_YEAR, 1, 2, SignStyle.NOT_NEGATIVE)
@@ -225,21 +227,25 @@ public class SqlFunctions {
           .appendValue(ChronoField.DAY_OF_MONTH, 1, 2, SignStyle.NOT_NEGATIVE)
           // Everything after the date is optional. Optional sections can be nested.
           .optionalStart()
-          // BQ accepts either a literal 'T' or a space to separate the date from the time,
+          // Accept either a literal 'T' or a space to separate the date from the time,
           // so make the 'T' optional but pad with 1 space if it's omitted.
           .padNext(1, ' ')
           .optionalStart()
+          .parseCaseInsensitive()
           .appendLiteral('T')
           .optionalEnd()
-          // Unlike ISO 8601, BQ can support single-digit hour, minute, and second parts.
+          // Support single-digit hour, minute, and second parts.
           .appendValue(ChronoField.HOUR_OF_DAY, 1, 2, SignStyle.NOT_NEGATIVE)
           .appendLiteral(':')
           .appendValue(ChronoField.MINUTE_OF_HOUR, 1, 2, SignStyle.NOT_NEGATIVE)
           .appendLiteral(':')
           .appendValue(ChronoField.SECOND_OF_MINUTE, 1, 2, SignStyle.NOT_NEGATIVE)
-          // ISO 8601 supports up to nanosecond precision, but BQ only up to microsecond.
+          // Calcite's internal representation for timestamps (integer milliseconds since epoch)
+          // does not support nanosecond precision, but we will pretend like it does for the purpose
+          // of parsing timestamp literals. Sub-millisecond precision will be truncated :(.
+          // See [CALCITE-5308].
           .optionalStart()
-          .appendFraction(ChronoField.MICRO_OF_SECOND, 0, 6, true)
+          .appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true)
           .optionalEnd()
           .optionalStart()
           .parseLenient()
@@ -4404,25 +4410,40 @@ public static long datetime(long millisSinceEpoch, String timeZone) {
   public static long timestamp(String expression) {
     // Calcite represents TIMESTAMP WITH LOCAL TIME ZONE as Unix integers
     // (milliseconds since epoch).
-    return parseBigQueryTimestampLiteral(expression).toInstant().toEpochMilli();
+    return parseTimestampLiteralPermissively(expression, UTC_ZONE_ID).toInstant().toEpochMilli();
   }
 
   /** SQL {@code TIMESTAMP(<string>, <timeZone>)} function. */
   public static long timestamp(String expression, String timeZone) {
     // Calcite represents TIMESTAMP WITH LOCAL TIME ZONE as Unix integers
     // (milliseconds since epoch).
-    return parseBigQueryTimestampLiteral(expression)
-        .atZoneSimilarLocal(ZoneId.of(timeZone))
+    return parseTimestampLiteralPermissively(expression, ZoneId.of(timeZone))
         .toInstant()
         .toEpochMilli();
   }
 
-  private static OffsetDateTime parseBigQueryTimestampLiteral(String expression) {
-    // First try to parse with an offset, otherwise parse as a local and assume
-    // UTC ("no offset").
+  private static OffsetDateTime parseTimestampLiteralPermissively(
+      String expression, ZoneId defaultZoneId) {
+    // First, look for a zone ID, e.g. "America/Los_Angeles", at the end of the expression.
+    // This is different from a zone offset, e.g. "-07:00".
+    final int lastSpaceIndex = expression.lastIndexOf(' ');
+    if (lastSpaceIndex > 0 && lastSpaceIndex < expression.length() - 1) {
+      final String maybeZoneId = expression.substring(lastSpaceIndex + 1);
+      try {
+        // Look up the zone ID, supplanting defaultZoneId if it's valid.
+        defaultZoneId = ZoneId.of(maybeZoneId);
+        // If the zone ID lookup succeeded, parse the rest of the expression without it.
+        // We'll apply the right offset before returning.
+        expression = expression.substring(0, lastSpaceIndex);
+      } catch (DateTimeException e) {
+        // maybeZoneId lookup failed. Neither the expression nor defaultZoneId has been modified.
+      }
+    }
+
+    // Try to parse with an offset,
+    // otherwise parse as a local datetime and apply the default zone ID.
     try {
-      return OffsetDateTime.parse(expression,
-          BIG_QUERY_TIMESTAMP_LITERAL_FORMATTER);
+      return OffsetDateTime.parse(expression, TIMESTAMP_LITERAL_FORMATTER);
     } catch (DateTimeParseException e) {
       // ignore
     }
@@ -4432,20 +4453,19 @@ private static OffsetDateTime parseBigQueryTimestampLiteral(String expression) {
       // match "+00:00".
       try {
         expression += ":00";
-        return OffsetDateTime.parse(expression,
-            BIG_QUERY_TIMESTAMP_LITERAL_FORMATTER);
+        return OffsetDateTime.parse(expression, TIMESTAMP_LITERAL_FORMATTER);
       } catch (DateTimeParseException e) {
         // ignore
       }
     }
     try {
-      return LocalDateTime
-          .parse(expression, BIG_QUERY_TIMESTAMP_LITERAL_FORMATTER)
-          .atOffset(ZoneOffset.UTC);
+      LocalDateTime localDateTime =
+          LocalDateTime.parse(expression, TIMESTAMP_LITERAL_FORMATTER);
+      return localDateTime.atOffset(
+          defaultZoneId.getRules().getOffset(localDateTime));
     } catch (DateTimeParseException e2) {
       throw new IllegalArgumentException(
-          String.format(Locale.ROOT,
-              "Could not parse BigQuery timestamp literal: %s", expression),
+          String.format(Locale.ROOT, "Could not parse timestamp literal: %s", expression),
           e2);
     }
   }
@@ -4487,8 +4507,7 @@ public static long timestamp(long millisSinceEpoch, String timeZone) {
     // TIME ZONE and TIMESTAMP, respectively) are represented internally as
     // milliseconds since epoch UTC and epoch.
     final Instant instant = Instant.ofEpochMilli(millisSinceEpoch);
-    final ZoneId utcZone = ZoneId.of("UTC");
-    return OffsetDateTime.ofInstant(instant, utcZone)
+    return OffsetDateTime.ofInstant(instant, UTC_ZONE_ID)
         .atZoneSimilarLocal(ZoneId.of(timeZone))
         .toInstant()
         .toEpochMilli();
@@ -4531,10 +4550,9 @@ public static int time(long timestampMillis, String timeZone) {
     if (v == null) {
       return castNonNull(null);
     }
-    return new TimestampWithTimeZoneString(v)
-        .withTimeZone(DateTimeUtils.UTC_ZONE)
-        .getLocalTimestampString()
-        .getMillisSinceEpoch();
+    return parseTimestampLiteralPermissively(v, UTC_ZONE_ID)
+        .toInstant()
+        .toEpochMilli();
   }
 
   public static @PolyNull Long toTimestampWithLocalTimeZone(@PolyNull String v,
@@ -4542,10 +4560,9 @@ public static int time(long timestampMillis, String timeZone) {
     if (v == null) {
       return castNonNull(null);
     }
-    return new TimestampWithTimeZoneString(v + " " + timeZone.getID())
-        .withTimeZone(DateTimeUtils.UTC_ZONE)
-        .getLocalTimestampString()
-        .getMillisSinceEpoch();
+    return parseTimestampLiteralPermissively(v, timeZone.toZoneId())
+        .toInstant()
+        .toEpochMilli();
   }
 
   // Don't need shortValueOf etc. - Short.valueOf is sufficient.
@@ -5002,6 +5019,17 @@ public static int customDateDiff(DataContext root,
     return timeFrameSet.diffDate(date, date2, timeFrame);
   }
 
+  /** SQL {@code EXTRACT} function applied to a custom time frame.
+   *
+   * <p>Unlike other DATE/TIME functions that accept custom time frames,
+   * EXTRACT currently only accepts ISOWEEK and WEEK(WEEKDAY). */
+  public static long customDateExtract(DataContext root, String timeFrameName, long date) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.extractDate((int) date, timeFrame);
+  }
+
   /** SQL {@code TIMESTAMPDIFF} function applied to a custom time frame.
    *
    * <p>Custom time frames are created and accessed as described in
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java b/core/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java
index a1e68becc9a..17015f0d310 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java
@@ -125,7 +125,7 @@ public SqlDataTypeSpec(
   //~ Methods ----------------------------------------------------------------
 
   @Override public SqlNode clone(SqlParserPos pos) {
-    return new SqlDataTypeSpec(typeNameSpec, timeZone, pos);
+    return new SqlDataTypeSpec(typeNameSpec, timeZone, nullable, pos);
   }
 
   @Override public SqlMonotonicity getMonotonicity(SqlValidatorScope scope) {
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlInternalOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlInternalOperator.java
index 70c590650af..87d21667c8b 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlInternalOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlInternalOperator.java
@@ -77,7 +77,7 @@ public SqlInternalOperator(
   //~ Methods ----------------------------------------------------------------
 
   @Override public SqlSyntax getSyntax() {
-    return SqlSyntax.INTERNAL;
+    return SqlSyntax.FUNCTION;
   }
 
   @Override public RelDataType deriveType(SqlValidator validator,
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
index 58fc0e5b5b5..1f39f742419 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
@@ -539,8 +539,10 @@ public RelDataType inferReturnType(
       }
 
       // MEASURE wrapper should be removed, e.g. MEASURE<DOUBLE> should just be DOUBLE
-      if (isMeasure(returnType) && returnType.getMeasureElementType() != null) {
-        returnType = Objects.requireNonNull(returnType.getMeasureElementType());
+      if (opBinding.getOperator().kind != SqlKind.AS
+          && isMeasure(returnType)
+          && returnType.getMeasureElementType() != null) {
+        returnType = returnType.getMeasureElementType();
       }
 
       if (operandTypeInference != null
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlUserDefinedTypeNameSpec.java b/core/src/main/java/org/apache/calcite/sql/SqlUserDefinedTypeNameSpec.java
index e4fb781d78c..d736f78c7b1 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlUserDefinedTypeNameSpec.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlUserDefinedTypeNameSpec.java
@@ -18,9 +18,12 @@
 
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.util.Litmus;
 
+import static org.apache.calcite.util.Static.RESOURCE;
+
 /**
  * A sql type name specification of user defined type.
  *
@@ -29,28 +32,61 @@
  */
 public class SqlUserDefinedTypeNameSpec extends SqlTypeNameSpec {
 
+  /** Like {@link SqlBasicTypeNameSpec}, user-defined types may have precision in certain cases. */
+  private int precision;
+
   /**
    * Create a SqlUserDefinedTypeNameSpec instance.
    *
    * @param typeName Type name as SQL identifier
    * @param pos The parser position
    */
-  public SqlUserDefinedTypeNameSpec(SqlIdentifier typeName, SqlParserPos pos) {
+  public SqlUserDefinedTypeNameSpec(SqlIdentifier typeName, int precision, SqlParserPos pos) {
     super(typeName, pos);
+    this.precision = precision;
+  }
+
+  public SqlUserDefinedTypeNameSpec(SqlIdentifier typeName, SqlParserPos pos) {
+    this(typeName, -1, pos);
   }
 
   public SqlUserDefinedTypeNameSpec(String name, SqlParserPos pos) {
-    this(new SqlIdentifier(name, pos), pos);
+    this(new SqlIdentifier(name, pos), -1, pos);
+  }
+
+  public SqlUserDefinedTypeNameSpec(String name, int precision, SqlParserPos pos) {
+    this(new SqlIdentifier(name, pos), precision, pos);
   }
 
   @Override public RelDataType deriveType(SqlValidator validator) {
-    // The type name is a compound identifier, that means it is a UDT,
-    // use SqlValidator to deduce its type from the Schema.
-    return validator.getValidatedNodeType(getTypeName());
+    // The type name is a compound identifier. That means it is a UDT.
+    // Use SqlValidator to deduce its type from the Schema.
+    final SqlIdentifier identifier = getTypeName();
+    RelDataType type = validator.getValidatedNodeTypeIfKnown(identifier);
+    if (type != null) {
+      return type;
+    }
+
+    // If the type does not exist in the UDT map, try a sensible default.
+    try {
+      SqlTypeName defaultTypeName = SqlTypeName.lookup(identifier.toString());
+      return new SqlBasicTypeNameSpec(defaultTypeName, precision, getParserPos())
+          .deriveType(validator);
+    } catch (IllegalArgumentException e) {
+      throw validator.newValidationError(
+          identifier, RESOURCE.unknownIdentifier(identifier.toString()));
+    }
   }
 
   @Override public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
     getTypeName().unparse(writer, leftPrec, rightPrec);
+
+    if (precision >= 0) {
+      final SqlWriter.Frame frame =
+          writer.startList(SqlWriter.FrameTypeEnum.FUN_CALL, "(", ")");
+      writer.print(precision);
+      writer.endList(frame);
+    }
   }
 
   @Override public boolean equalsDeep(SqlTypeNameSpec spec, Litmus litmus) {
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlExtractFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlExtractFunction.java
index 1c8a20b0ad7..399fff74227 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlExtractFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlExtractFunction.java
@@ -35,7 +35,6 @@
 
 import com.google.common.collect.ImmutableSet;
 
-import static org.apache.calcite.sql.validate.SqlNonNullableAccessors.getOperandLiteralValueOrThrow;
 import static org.apache.calcite.util.Static.RESOURCE;
 
 /**
@@ -203,11 +202,12 @@ public SqlExtractFunction(String name) {
   }
 
   @Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
-    TimeUnitRange value = getOperandLiteralValueOrThrow(call, 0, TimeUnitRange.class);
-    switch (value) {
-    case YEAR:
+    // If string value of first operand is anything except YEAR,
+    // return NOT_MONOTONIC.
+    Object value = call.getOperandLiteralValue(0, Object.class);
+    if (value != null && value.toString().equals("YEAR")) {
       return call.getOperandMonotonicity(1).unstrict();
-    default:
+    } else {
       return SqlMonotonicity.NOT_MONOTONIC;
     }
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java
index 6996ecb3160..e52278b5139 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java
@@ -725,7 +725,6 @@ static RelDataType deriveTypeSplit(SqlOperatorBinding operatorBinding,
               ReturnTypes.DOUBLE,
               OperandTypes.NUMERIC_UNIT_INTERVAL_NUMERIC_LITERAL)
           .withFunctionType(SqlFunctionCategory.SYSTEM)
-          .withOver(true)
           .withPercentile(true)
           .withAllowsNullTreatment(true)
           .withAllowsFraming(false);
@@ -740,7 +739,6 @@ static RelDataType deriveTypeSplit(SqlOperatorBinding operatorBinding,
               ReturnTypes.ARG0,
               OperandTypes.NUMERIC_UNIT_INTERVAL_NUMERIC_LITERAL)
           .withFunctionType(SqlFunctionCategory.SYSTEM)
-          .withOver(true)
           .withPercentile(true)
           .withAllowsNullTreatment(true)
           .withAllowsFraming(false);
@@ -802,7 +800,9 @@ static RelDataType deriveTypeSplit(SqlOperatorBinding operatorBinding,
               // DATETIME(timestampLtz, timeZone)
               OperandTypes.sequence(
                   "DATETIME(TIMESTAMP WITH LOCAL TIME ZONE, VARCHAR)",
-                  OperandTypes.TIMESTAMP_LTZ, OperandTypes.CHARACTER)),
+                  OperandTypes.TIMESTAMP_LTZ, OperandTypes.CHARACTER),
+              // DATETIME(timestamp) -- This is a no-op.
+              OperandTypes.TIMESTAMP_NTZ),
           SqlFunctionCategory.TIMEDATE);
 
   /** The "TIME" function. It has the following overloads:
@@ -857,7 +857,9 @@ static RelDataType deriveTypeSplit(SqlOperatorBinding operatorBinding,
               OperandTypes.TIMESTAMP_NTZ,
               // TIMESTAMP(timestamp, timeZone)
               OperandTypes.sequence("TIMESTAMP(TIMESTAMP, VARCHAR)",
-                  OperandTypes.TIMESTAMP_NTZ, OperandTypes.CHARACTER)),
+                  OperandTypes.TIMESTAMP_NTZ, OperandTypes.CHARACTER),
+              // TIMESTAMP(timestampLtz) -- This is a no-op.
+              OperandTypes.TIMESTAMP_LTZ),
           SqlFunctionCategory.TIMEDATE);
 
   /** The "CURRENT_DATETIME([timezone])" function. */
@@ -1812,11 +1814,14 @@ private static RelDataType deriveTypeMapFromEntries(SqlOperatorBinding opBinding
               SqlTypeFamily.ANY));
 
   /** The "DATE_TRUNC(date, timeUnit)" function (BigQuery);
-   * truncates a DATE value to the beginning of a timeUnit. */
+   * truncates a DATE value to the beginning of a timeUnit.
+   *
+   * <p> TODO(CALCITE-5290): Add `DATE_TRUNC` function consistent with Postgres. Currently, Postgres
+   *  style calls can be parsed but fail validation. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction DATE_TRUNC =
       SqlBasicFunction.create("DATE_TRUNC",
-          ReturnTypes.ARG0_NULLABLE,
+          ReturnTypes.FIRST_DATETIME_ARG,
           OperandTypes.sequence("'DATE_TRUNC(<DATE>, <DATETIME_INTERVAL>)'",
               OperandTypes.DATE_OR_TIMESTAMP, OperandTypes.dateInterval()),
           SqlFunctionCategory.TIMEDATE)
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
index 93f510518bc..3dd42bdfe78 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
@@ -1560,6 +1560,10 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    */
   public static final SqlSpecialOperator REINTERPRET =
       new SqlSpecialOperator("Reinterpret", SqlKind.REINTERPRET) {
+        @Override public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
+          call.operand(0).unparse(writer, leftPrec, rightPrec);
+        }
+
         @Override public SqlOperandCountRange getOperandCountRange() {
           return SqlOperandCountRanges.between(1, 2);
         }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java b/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
index 386ed96fb91..65a61af1092 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
@@ -291,6 +291,23 @@ public static SqlCall stripSeparator(SqlCall call) {
         return type1;
       };
 
+  /**
+   * Type-inference strategy that uses the first operand that is a member of
+   * {@link SqlTypeFamily#DATETIME} as the return type.
+   */
+  public static final SqlReturnTypeInference FIRST_DATETIME_ARG =
+      opBinding -> {
+        final int n = opBinding.getOperandCount();
+        RelDataType type1 = null;
+        for (int i = 0; i < n; i++) {
+          type1 = opBinding.getOperandType(i);
+          if (SqlTypeUtil.isDatetime(type1)) {
+            break;
+          }
+        }
+        return type1;
+      };
+
   /**
    * Type-inference strategy whereby the result type of a call is a nullable
    * Boolean.
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/AbstractNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/AbstractNamespace.java
index 4ce24bd5ddf..334f1746a92 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/AbstractNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/AbstractNamespace.java
@@ -20,7 +20,6 @@
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 
@@ -58,9 +57,13 @@ abstract class AbstractNamespace implements SqlValidatorNamespace {
   /** As {@link #rowType}, but not necessarily a struct. */
   protected @Nullable RelDataType type;
 
-  /** Ordinals of fields that must be filtered. Initially the empty set, but
-   * should typically be re-assigned on validate. */
-  protected ImmutableBitSet mustFilterFields = ImmutableBitSet.of();
+  /**
+   * Class that holds information about what fields need to be filtered, what bypass-fields
+   * can defuse the errors if they are filtered on as an alternative, and a set used during
+   * validation internally. Initialized as empty object, but should typically be re-assiged
+   * on validate.
+   */
+  protected FilterRequirement filterRequirement = new FilterRequirement();
 
   protected final @Nullable SqlNode enclosingNode;
 
@@ -164,9 +167,9 @@ abstract class AbstractNamespace implements SqlValidatorNamespace {
     return ImmutableList.of();
   }
 
-  @Override public ImmutableBitSet getMustFilterFields() {
-    return requireNonNull(mustFilterFields,
-        "mustFilterFields (maybe validation is not complete?)");
+  @Override public FilterRequirement getFilterRequirement() {
+    return requireNonNull(filterRequirement,
+        "filterRequirement (maybe validation is not complete?)");
   }
 
   @Override public SqlMonotonicity getMonotonicity(String columnName) {
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/FilterRequirement.java b/core/src/main/java/org/apache/calcite/sql/validate/FilterRequirement.java
new file mode 100644
index 00000000000..22c1826e1a9
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/validate/FilterRequirement.java
@@ -0,0 +1,118 @@
+/*
+ * 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.calcite.sql.validate;
+
+import org.apache.calcite.util.ImmutableBitSet;
+
+import com.google.common.collect.ImmutableSet;
+
+import java.util.Set;
+
+/**
+ * Class that encapsulates filtering requirements when overloading SemanticTable. <br>
+ *
+ * <p>A few examples of the behavior:<br>
+ *
+ * <p>Table <code>t</code> has a must-filter field <code>f</code> and bypass-fields <code>b0</code>
+ * and <code>b1</code>.<br>
+ * SQL: <code>select f from t;</code><br> -> Errors because there's no filter on f. <br>
+ * SQL: <code>select * from (select f from t);</code><br> -> Errors at the inner query because
+ * there's no filter on f. <br>
+ * SQL: <code>select f from t where f = 1;</code><br> -> Valid because there is a filter on f.<br>
+ * SQL: <code>select * from (select f from t) where f = 1;</code><br> -> Valid because there is a
+ * filter on f. <br>
+ * SQL: <code>select f from t where b0 = 1;</code><br> -> Valid because there is a filter on
+ * bypass-field b0.<br>
+ *
+ * <p>Some notes on remnantFilterFields.<br>
+ * remnantFilterFields is used to identify whether the query should error
+ * at the top level query. It is populated with the filter-field value when a filter-field is not
+ * selected or filtered on, but a bypass-field for the table is selected.
+ * The remnantFilterFields are no longer accessible by the enclosing query and hence can no
+ * longer be defused by filtering on it; however, it can be defused if the bypass-field is
+ * filtered on, hence we need to keep track of it.
+
+ * Example:<br>
+ * Table <code>t</code> has a must-filter field <code>f</code> and bypass-fields <code>b0</code>
+ *  and <code>b1</code>.<br>
+ * SQL: <code>select b0, b1 from t;</code><br>
+ *
+ * <p>This results in: <br>
+ * filterFields:[]<br>
+ * bypassFields:[b0, b1]<br>
+ * remnantFilterFields: [f]<br>
+ * -> Errors because it is a top level query and remnantFilterFields is not empty. <br>
+ *
+ * <p>SQL: <code>select * from (select b0, b1 from t) where b0 = 1;</code><br>
+ * When unwrapping the inner query we get the same FilterRequirement as the previous example:<br>
+ * filterFields:[]<br>
+ * bypassFields:[b0, b1]<br>
+ * remnantFilterFields: [f]<br>
+ * When unwrapping the top level query, the filter on b0 defuses the remnantFilterField requirement
+ * of [f] because it originated from the same table, resulting in the following: <br>
+ * filterFields:[]<br>
+ * bypassFields:[b0, b1]<br>
+ * remnantFilterFields: []<br>
+ * -> Valid because remnantFilterFields is empty now.
+ */
+final class FilterRequirement {
+
+  /** The ordinals (in the row type) of the "must-filter" fields,
+   * fields that must be filtered in a query.*/
+  private final ImmutableBitSet filterFields;
+  /** The ordinals (in the row type) of the "bypass" fields,
+   * fields that can defuse validation errors on filterFields if filtered on. */
+  private final ImmutableBitSet bypassFields;
+  /** Set of filterField SqlQualifieds that have not been defused
+   * in the current query, but can still be defused by filtering on a bypass field in the
+   * enclosing query.*/
+  private final ImmutableSet<SqlQualified> remnantFilterFields;
+
+  /**
+   * Creates a <code>FilterRequirement</code>.
+   *
+   * @param filterFields Ordinals of the "must-filter" fields.
+   * @param bypassFields Ordinals of the "bypass" fields.
+   * @param remnantFilterFields Filter fields that can no longer be filtered on,
+   * but can only be defused if a bypass field is filtered on.
+   */
+  FilterRequirement(ImmutableBitSet filterFields,
+      ImmutableBitSet bypassFields, Set<SqlQualified> remnantFilterFields) {
+    this.filterFields = ImmutableBitSet.of(filterFields);
+    this.bypassFields = ImmutableBitSet.of(bypassFields);
+    this.remnantFilterFields = ImmutableSet.copyOf(remnantFilterFields);
+  }
+
+  /** Creates an empty FilterRequirement. */
+  FilterRequirement() {
+    this(ImmutableBitSet.of(), ImmutableBitSet.of(), ImmutableSet.of());
+  }
+  /** Returns filterFields. */
+  public ImmutableBitSet getFilterFields() {
+    return filterFields;
+  }
+
+  /** Returns bypassFields. */
+  public ImmutableBitSet getBypassFields() {
+    return bypassFields;
+  }
+
+  /** Returns remnantFilterFields. */
+  public ImmutableSet<SqlQualified> getRemnantFilterFields() {
+    return remnantFilterFields;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/IdentifierNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/IdentifierNamespace.java
index 770f8b9d2ac..037e646a16e 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/IdentifierNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/IdentifierNamespace.java
@@ -210,7 +210,7 @@ private SqlValidatorNamespace resolveImpl(SqlIdentifier id) {
       }
     }
 
-    this.mustFilterFields = resolvedNamespace.getMustFilterFields();
+    filterRequirement = resolvedNamespace.getFilterRequirement();
     RelDataType rowType = resolvedNamespace.getRowType();
 
     if (extendList != null) {
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SemanticTable.java b/core/src/main/java/org/apache/calcite/sql/validate/SemanticTable.java
index b115dbb4ccc..6b39af7065c 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SemanticTable.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SemanticTable.java
@@ -16,8 +16,12 @@
  */
 package org.apache.calcite.sql.validate;
 
+import com.google.common.collect.ImmutableList;
+
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.List;
+
 /**
  * Extension to {@link SqlValidatorTable} with extra, optional metadata.
  *
@@ -44,4 +48,12 @@ public interface SemanticTable {
   default boolean mustFilter(int column) {
     return getFilter(column) != null;
   }
+
+  /**
+   * Returns a list of column ordinals (0-based) of fields that defuse
+   * must-filter columns when filtered on.
+   */
+  default List<Integer> bypassFieldList() {
+    return ImmutableList.of();
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlConformance.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlConformance.java
index 896db041e87..cdd31b7702f 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlConformance.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlConformance.java
@@ -149,6 +149,16 @@ public interface SqlConformance {
    */
   boolean isSortByOrdinal();
 
+  /**
+   * MSSQL can sort by ordinal, but it really shouldn't.
+   * Introducing this crutch until we can properly fix Calcite's support for it.
+   *
+   * <p> https://issues.apache.org/jira/browse/CALCITE-5866
+   */
+  default boolean shouldSortByOrdinal() {
+    return isSortByOrdinal();
+  }
+
   /**
    * Whether '{@code ORDER BY x}' is interpreted to mean 'sort by the select
    * list item whose alias is x' even if there is a column called x.
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index a0e970fadbd..fb550f5a7cf 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -156,6 +156,7 @@
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
 import static com.google.common.base.Preconditions.checkArgument;
@@ -1167,17 +1168,27 @@ protected void validateNamespace(final SqlValidatorNamespace namespace,
       setValidatedNodeType(node, namespace.getType());
 
       if (node == top) {
-        // A top-level namespace must not return any must-filter fields.
+        FilterRequirement filterRequirement = namespace.getFilterRequirement();
+        // Either of the following two conditions result in an invalid query:
+        // 1) A top-level namespace must not return any must-filter fields.
         // A non-top-level namespace (e.g. a subquery) may return must-filter
         // fields; these are neutralized if the consuming query filters on them.
-        final ImmutableBitSet mustFilterFields =
-            namespace.getMustFilterFields();
-        if (!mustFilterFields.isEmpty()) {
+        // 2) A top-level namespace must not have any remnant-must-filter fields.
+        // Remnant must filter fields are fields that are not selected and cannot
+        // be defused unless a bypass field defuses it.
+        if (!filterRequirement.getFilterFields().isEmpty()
+            || !filterRequirement.getRemnantFilterFields().isEmpty()) {
+          Stream<String> mustFilterStream =
+              StreamSupport.stream(filterRequirement.getFilterFields().spliterator(), false)
+              .map(namespace.getRowType().getFieldNames()::get);
+          Stream<String> remnantStream =
+              filterRequirement.getRemnantFilterFields().stream()
+              .map(q -> q.suffix().get(0));
+
           // Set of field names, sorted alphabetically for determinism.
           Set<String> fieldNameSet =
-              StreamSupport.stream(mustFilterFields.spliterator(), false)
-                  .map(namespace.getRowType().getFieldNames()::get)
-                  .collect(Collectors.toCollection(TreeSet::new));
+              Stream.concat(mustFilterStream, remnantStream)
+              .collect(Collectors.toCollection(TreeSet::new));
           throw newValidationError(node,
               RESOURCE.mustFilterFieldsMissing(fieldNameSet.toString()));
         }
@@ -3892,64 +3903,7 @@ protected void validateSelect(
         validateSelectList(selectItems, select, targetRowType);
     ns.setType(rowType);
 
-    // Deduce which columns must be filtered.
-    ns.mustFilterFields = ImmutableBitSet.of();
-    if (from != null) {
-      final Set<SqlQualified> qualifieds = new LinkedHashSet<>();
-      for (ScopeChild child : fromScope.children) {
-        final List<String> fieldNames =
-            child.namespace.getRowType().getFieldNames();
-        child.namespace.getMustFilterFields()
-            .forEachInt(i ->
-                qualifieds.add(
-                    SqlQualified.create(fromScope, 1, child.namespace,
-                        new SqlIdentifier(
-                            ImmutableList.of(child.name, fieldNames.get(i)),
-                            SqlParserPos.ZERO))));
-      }
-      if (!qualifieds.isEmpty()) {
-        if (select.getWhere() != null) {
-          forEachQualified(select.getWhere(), getWhereScope(select),
-              qualifieds::remove);
-        }
-        if (select.getHaving() != null) {
-          forEachQualified(select.getHaving(), getHavingScope(select),
-              qualifieds::remove);
-        }
-
-        // Each of the must-filter fields identified must be returned as a
-        // SELECT item, which is then flagged as must-filter.
-        final BitSet mustFilterFields = new BitSet();
-        final List<SqlNode> expandedSelectItems =
-            requireNonNull(fromScope.getExpandedSelectList(),
-                "expandedSelectList");
-        forEach(expandedSelectItems, (selectItem, i) -> {
-          selectItem = stripAs(selectItem);
-          if (selectItem instanceof SqlIdentifier) {
-            SqlQualified qualified =
-                fromScope.fullyQualify((SqlIdentifier) selectItem);
-            if (qualifieds.remove(qualified)) {
-              // SELECT item #i referenced a must-filter column that was not
-              // filtered in the WHERE or HAVING. It becomes a must-filter
-              // column for our consumer.
-              mustFilterFields.set(i);
-            }
-          }
-        });
-
-        // If there are must-filter fields that are not in the SELECT clause,
-        // this is an error.
-        if (!qualifieds.isEmpty()) {
-          throw newValidationError(select,
-              RESOURCE.mustFilterFieldsMissing(
-                  qualifieds.stream()
-                      .map(q -> q.suffix().get(0))
-                      .collect(Collectors.toCollection(TreeSet::new))
-                      .toString()));
-        }
-        ns.mustFilterFields = ImmutableBitSet.fromBitSet(mustFilterFields);
-      }
-    }
+    validateMustFilterRequirements(select, ns);
 
     // Validate ORDER BY after we have set ns.rowType because in some
     // dialects you can refer to columns of the select list, e.g.
@@ -3966,8 +3920,10 @@ protected void validateSelect(
     }
   }
 
-  /** For each identifier in an expression, resolves it to a qualified name
-   * and calls the provided action. */
+  /**
+   * For each identifier in an expression, resolves it to a qualified name
+   * and calls the provided action.
+   */
   private static void forEachQualified(SqlNode node, SqlValidatorScope scope,
       Consumer<SqlQualified> consumer) {
     node.accept(new SqlBasicVisitor<Void>() {
@@ -3979,6 +3935,49 @@ private static void forEachQualified(SqlNode node, SqlValidatorScope scope,
     });
   }
 
+  /**
+   * Removes all entries from qualifieds and remnantMustFilterFields if the supplied SqlNode
+   * is a bypassField.
+   */
+  private static void purgeForBypassFields(SqlNode node, SqlValidatorScope scope,
+      Set<SqlQualified> qualifieds, Set<SqlQualified> bypassQualifieds,
+      Set<SqlQualified> remnantMustFilterFields) {
+    node.accept(new SqlBasicVisitor<Void>() {
+      @Override public Void visit(SqlIdentifier id) {
+        final SqlQualified qualified = scope.fullyQualify(id);
+        if (bypassQualifieds.contains(qualified)) {
+          // Clear all the must-filter qualifieds from the same table identifier
+          Collection<SqlQualified> sameIdentifier = qualifieds.stream()
+              .filter(q -> qualifiedMatchesIdentifier(q, qualified))
+              .collect(Collectors.toList());
+          sameIdentifier.forEach(qualifieds::remove);
+
+          // Clear all the remnant must-filter qualifieds from the same table identifier
+          Collection<SqlQualified> sameIdentifier_ = remnantMustFilterFields.stream()
+              .filter(q -> qualifiedMatchesIdentifier(q, qualified))
+              .collect(Collectors.toList());
+          sameIdentifier_.forEach(remnantMustFilterFields::remove);
+        }
+        return null;
+      }
+    });
+  }
+
+  private static void toQualifieds(ImmutableBitSet fields, Set<SqlQualified> qualifiedSet,
+      SelectScope fromScope, ScopeChild child, List<String> fieldNames) {
+    fields.forEachInt(i ->
+        qualifiedSet.add(
+            SqlQualified.create(fromScope, 1, child.namespace,
+                new SqlIdentifier(
+                    ImmutableList.of(child.name, fieldNames.get(i)),
+                    SqlParserPos.ZERO))));
+
+  }
+
+  private static boolean qualifiedMatchesIdentifier(SqlQualified q1, SqlQualified q2) {
+    return q1.identifier.names.get(0).equals(q2.identifier.names.get(0));
+  }
+
   private void checkRollUpInSelectList(SqlSelect select) {
     SqlValidatorScope scope = getSelectScope(select);
     for (SqlNode item : SqlNonNullableAccessors.getSelectList(select)) {
@@ -4425,6 +4424,90 @@ protected void validateQualifyClause(SqlSelect select) {
     }
   }
 
+  protected void validateMustFilterRequirements(SqlSelect select, SelectNamespace ns) {
+    ns.filterRequirement = new FilterRequirement();
+    if (select.getFrom() != null) {
+      final SelectScope fromScope = (SelectScope) getFromScope(select);
+      final BitSet projectedNonFilteredBypassField = new BitSet();
+      final Set<SqlQualified> qualifieds = new LinkedHashSet<>();
+      final Set<SqlQualified> bypassQualifieds = new LinkedHashSet<>();
+      final Set<SqlQualified> remnantQualifieds = new LinkedHashSet<>();
+      for (ScopeChild child : fromScope.children) {
+        final List<String> fieldNames =
+            child.namespace.getRowType().getFieldNames();
+        FilterRequirement mustFilterReq = child.namespace.getFilterRequirement();
+        toQualifieds(mustFilterReq.getFilterFields(), qualifieds, fromScope, child,
+            fieldNames);
+        toQualifieds(mustFilterReq.getBypassFields(), bypassQualifieds, fromScope,
+            child, fieldNames);
+        remnantQualifieds.addAll(mustFilterReq.getRemnantFilterFields());
+      }
+      if (!qualifieds.isEmpty() || !bypassQualifieds.isEmpty()) {
+        if (select.getWhere() != null) {
+          forEachQualified(select.getWhere(), getWhereScope(select),
+              qualifieds::remove);
+          purgeForBypassFields(select.getWhere(), getWhereScope(select),
+              qualifieds, bypassQualifieds, remnantQualifieds);
+        }
+        if (select.getHaving() != null) {
+          forEachQualified(select.getHaving(), getHavingScope(select),
+              qualifieds::remove);
+          purgeForBypassFields(select.getHaving(), getHavingScope(select),
+              qualifieds, bypassQualifieds, remnantQualifieds);
+        }
+
+        // Each of the must-filter fields identified must be returned as a
+        // SELECT item, which is then flagged as must-filter.
+        final BitSet mustFilterFields = new BitSet();
+        // Each of the bypass fields identified must be returned as a
+        // SELECT item, which is then flagged as a bypass field for the consumer.
+        final BitSet mustFilterBypassFields = new BitSet();
+        final List<SqlNode> expandedSelectItems =
+            requireNonNull(fromScope.getExpandedSelectList(),
+                "expandedSelectList");
+        forEach(expandedSelectItems, (selectItem, i) -> {
+          selectItem = stripAs(selectItem);
+          if (selectItem instanceof SqlIdentifier) {
+            SqlQualified qualified =
+                fromScope.fullyQualify((SqlIdentifier) selectItem);
+            if (qualifieds.remove(qualified)) {
+              // SELECT item #i referenced a must-filter column that was not
+              // filtered in the WHERE or HAVING. It becomes a must-filter
+              // column for our consumer.
+              mustFilterFields.set(i);
+            }
+            if (bypassQualifieds.remove(qualified)) {
+              // SELECT item #i referenced a bypass column that was not filtered in the WHERE
+              // or HAVING. It becomes a bypass column for our consumer.
+              mustFilterBypassFields.set(i);
+              projectedNonFilteredBypassField.set(0);
+            }
+          }
+        });
+
+        // If there are must-filter fields that are not in the SELECT clause and there were no
+        // bypass-fields on this table, this is an error.
+        if (!qualifieds.isEmpty() && !projectedNonFilteredBypassField.get(0)) {
+          throw newValidationError(select,
+              RESOURCE.mustFilterFieldsMissing(
+                  qualifieds.stream()
+                      .map(q -> q.suffix().get(0))
+                      .collect(Collectors.toCollection(TreeSet::new))
+                      .toString()));
+        }
+        // Remaining must-filter fields can be defused by a bypass-field,
+        // so we pass this to the consumer.
+        ImmutableSet<SqlQualified> remnantMustFilterFields =
+            Stream.of(remnantQualifieds, qualifieds)
+                .flatMap(Set::stream).collect(ImmutableSet.toImmutableSet());
+        ns.filterRequirement =
+            new FilterRequirement(ImmutableBitSet.fromBitSet(mustFilterFields),
+                ImmutableBitSet.fromBitSet(mustFilterBypassFields),
+                remnantMustFilterFields);
+      }
+    }
+  }
+
   @Override public void validateWith(SqlWith with, SqlValidatorScope scope) {
     final SqlValidatorNamespace namespace = getNamespaceOrThrow(with);
     validateNamespace(namespace, unknownType);
@@ -6308,7 +6391,7 @@ private SqlNode navigationInDefine(SqlNode node, String alpha) {
     // Because there are two forms of the PERCENTILE_CONT/PERCENTILE_DISC functions,
     // they are distinguished by their operand count and then validated accordingly.
     // For example, the standard single operand form requires group order while the
-    // 2-operand form allows for null treatment and requires an OVER() clause.
+    // 2-operand form allows for null treatment.
     if (op.isPercentile()) {
       switch (aggCall.operandCount()) {
       case 1:
@@ -6334,7 +6417,6 @@ private SqlNode navigationInDefine(SqlNode node, String alpha) {
         break;
       case 2:
         assert op.allowsNullTreatment();
-        assert op.requiresOver();
         assert op.requiresGroupOrder() == Optionality.FORBIDDEN;
         break;
       default:
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorNamespace.java
index 77a8dc070e2..77679237fd6 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorNamespace.java
@@ -19,7 +19,6 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.Pair;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -214,9 +213,8 @@ default boolean fieldExists(String name) {
    */
   boolean supportsModality(SqlModality modality);
 
-  /** Returns the ordinals (in the row type) of the "must-filter" fields,
-   * fields that that must be filtered in a query. */
-  default ImmutableBitSet getMustFilterFields() {
-    return ImmutableBitSet.of();
+  /** Returns a FilterRequirement object used during validation. */
+  default FilterRequirement getFilterRequirement() {
+    return new FilterRequirement();
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/TableNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/TableNamespace.java
index 8e8ab27e3c9..00eead3c230 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/TableNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/TableNamespace.java
@@ -30,6 +30,7 @@
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -60,15 +61,18 @@ private TableNamespace(SqlValidatorImpl validator, SqlValidatorTable table,
   }
 
   @Override protected RelDataType validateImpl(RelDataType targetRowType) {
-    this.mustFilterFields = ImmutableBitSet.of();
     table.maybeUnwrap(SemanticTable.class)
-        .ifPresent(semanticTable ->
-            this.mustFilterFields =
-                table.getRowType().getFieldList().stream()
-                    .map(RelDataTypeField::getIndex)
-                    .filter(semanticTable::mustFilter)
-                    .collect(toImmutableBitSet()));
-
+        .ifPresent(semanticTable -> {
+          ImmutableBitSet mustFilterFields = table.getRowType().getFieldList().stream()
+              .map(RelDataTypeField::getIndex)
+              .filter(semanticTable::mustFilter)
+              .collect(toImmutableBitSet());
+          ImmutableBitSet bypassFieldList = ImmutableBitSet.of(semanticTable.bypassFieldList());
+          // We pass in an empty set for remnantMustFilterFields here because it isn't exposed to
+          // SemanticTable and only mustFilterFields and bypassFieldList should be supplied.
+          this.filterRequirement =
+              new FilterRequirement(mustFilterFields, bypassFieldList, ImmutableSet.of());
+        });
     if (extendedFields.isEmpty()) {
       return table.getRowType();
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/WithItemNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/WithItemNamespace.java
index 5c0a85756fa..dc41d92d3c8 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/WithItemNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/WithItemNamespace.java
@@ -41,7 +41,7 @@ class WithItemNamespace extends AbstractNamespace {
     final SqlValidatorNamespace childNs =
         validator.getNamespaceOrThrow(getQuery());
     final RelDataType rowType = childNs.getRowTypeSansSystemColumns();
-    mustFilterFields = childNs.getMustFilterFields();
+    filterRequirement = childNs.getFilterRequirement();
     SqlNodeList columnList = withItem.columnList;
     if (columnList == null) {
       return rowType;
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/WithNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/WithNamespace.java
index bec57b715b1..286b91d3cce 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/WithNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/WithNamespace.java
@@ -64,7 +64,7 @@ public class WithNamespace extends AbstractNamespace {
     validator.validateQuery(with.body, scope2, targetRowType);
     final RelDataType rowType = validator.getValidatedNodeType(with.body);
     validator.setValidatedNodeType(with, rowType);
-    mustFilterFields = bodyNamespace.getMustFilterFields();
+    filterRequirement = bodyNamespace.getFilterRequirement();
     return rowType;
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java b/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
index 1490229ff97..2a8743bd1c0 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
@@ -79,6 +79,7 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.util.Bug;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 
@@ -202,26 +203,34 @@ private StandardConvertletTable() {
 
     registerOp(SqlLibraryOperators.DATE_ADD,
         new TimestampAddConvertlet());
-    registerOp(SqlLibraryOperators.DATE_DIFF,
-        new TimestampDiffConvertlet());
+    if (Bug.CALCITE_3312_FIXED) {
+      registerOp(SqlLibraryOperators.DATE_DIFF,
+          new TimestampDiffConvertlet());
+    }
     registerOp(SqlLibraryOperators.DATE_SUB,
         new TimestampSubConvertlet());
     registerOp(SqlLibraryOperators.DATETIME_ADD,
         new TimestampAddConvertlet());
-    registerOp(SqlLibraryOperators.DATETIME_DIFF,
-        new TimestampDiffConvertlet());
+    if (Bug.CALCITE_3312_FIXED) {
+      registerOp(SqlLibraryOperators.DATETIME_DIFF,
+          new TimestampDiffConvertlet());
+    }
     registerOp(SqlLibraryOperators.DATETIME_SUB,
         new TimestampSubConvertlet());
     registerOp(SqlLibraryOperators.TIME_ADD,
         new TimestampAddConvertlet());
-    registerOp(SqlLibraryOperators.TIME_DIFF,
-        new TimestampDiffConvertlet());
+    if (Bug.CALCITE_3312_FIXED) {
+      registerOp(SqlLibraryOperators.TIME_DIFF,
+          new TimestampDiffConvertlet());
+    }
     registerOp(SqlLibraryOperators.TIME_SUB,
         new TimestampSubConvertlet());
     registerOp(SqlLibraryOperators.TIMESTAMP_ADD2,
         new TimestampAddConvertlet());
-    registerOp(SqlLibraryOperators.TIMESTAMP_DIFF3,
-        new TimestampDiffConvertlet());
+    if (Bug.CALCITE_3312_FIXED) {
+      registerOp(SqlLibraryOperators.TIMESTAMP_DIFF3,
+          new TimestampDiffConvertlet());
+    }
     registerOp(SqlLibraryOperators.TIMESTAMP_SUB,
         new TimestampSubConvertlet());
 
diff --git a/core/src/main/java/org/apache/calcite/util/Bug.java b/core/src/main/java/org/apache/calcite/util/Bug.java
index e0eaa97a3ec..652c8146091 100644
--- a/core/src/main/java/org/apache/calcite/util/Bug.java
+++ b/core/src/main/java/org/apache/calcite/util/Bug.java
@@ -162,6 +162,11 @@ public abstract class Bug {
    * JSON data type support</a> is fixed. */
   public static final boolean CALCITE_2869_FIXED = false;
 
+  /** Whether
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-3312">[CALCITE-3312]
+   * TIMESTAMPDIFF cannot be converted to SQL</a> is fixed. */
+  public static final boolean CALCITE_3312_FIXED = false;
+
   /** Whether
    * <a href="https://issues.apache.org/jira/browse/CALCITE-3243">[CALCITE-3243]
    * Incomplete validation of operands in JSON functions</a> is fixed. */
diff --git a/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java b/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
index 2e72df1be65..ea3ec47810e 100644
--- a/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
+++ b/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
@@ -680,6 +680,8 @@ public enum BuiltInMethod {
       DataContext.class, String.class, int.class, int.class),
   CUSTOM_DATE_DIFF(SqlFunctions.class, "customDateDiff",
       DataContext.class, String.class, int.class, int.class),
+  CUSTOM_DATE_EXTRACT(SqlFunctions.class, "customDateExtract",
+      DataContext.class, String.class, long.class),
   CUSTOM_DATE_FLOOR(SqlFunctions.class, "customDateFloor",
       DataContext.class, String.class, int.class),
   CUSTOM_DATE_CEIL(SqlFunctions.class, "customDateCeil",
diff --git a/core/src/main/java/org/apache/calcite/util/Sources.java b/core/src/main/java/org/apache/calcite/util/Sources.java
index d1846505564..53b2d4e8652 100644
--- a/core/src/main/java/org/apache/calcite/util/Sources.java
+++ b/core/src/main/java/org/apache/calcite/util/Sources.java
@@ -191,22 +191,30 @@ private File fileNonNull() {
     }
 
     private static @Nullable File urlToFile(URL url) {
-      if (!"file".equals(url.getProtocol())) {
+      switch (url.getProtocol()) {
+      case "jar":
+        try {
+          return urlToFile(new URL(url.getFile()));
+        } catch (MalformedURLException e) {
+          return null;
+        }
+      case "file":
+        URI uri;
+        try {
+          uri = url.toURI();
+        } catch (URISyntaxException e) {
+          throw new IllegalArgumentException("Unable to convert URL " + url + " to URI", e);
+        }
+        if (uri.isOpaque()) {
+          // It is like file:test%20file.c++
+          // getSchemeSpecificPart would return "test file.c++"
+          return new File(uri.getSchemeSpecificPart());
+        }
+        // See https://stackoverflow.com/a/17870390/1261287
+        return Paths.get(uri).toFile();
+      default:
         return null;
       }
-      URI uri;
-      try {
-        uri = url.toURI();
-      } catch (URISyntaxException e) {
-        throw new IllegalArgumentException("Unable to convert URL " + url + " to URI", e);
-      }
-      if (uri.isOpaque()) {
-        // It is like file:test%20file.c++
-        // getSchemeSpecificPart would return "test file.c++"
-        return new File(uri.getSchemeSpecificPart());
-      }
-      // See https://stackoverflow.com/a/17870390/1261287
-      return Paths.get(uri).toFile();
     }
 
     private static URL fileToUrl(File file) {
diff --git a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
index 45c8935a915..08ab9436c0e 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
@@ -295,8 +295,8 @@ private static ResultSet getTableTypes(Connection connection) {
                 + "SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; "
                 + "CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=1; IS_NULLABLE=NO; "
                 + "SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; "
-                + "SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; "
-                + "IS_GENERATEDCOLUMN="));
+                + "SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=NO; "
+                + "IS_GENERATEDCOLUMN=NO"));
   }
 
   /** Checks that the default {@code getTables()} response contains the 10
diff --git a/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java b/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
index 6e55237bc9a..a4e8d3e77d2 100644
--- a/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
@@ -83,7 +83,6 @@
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.tools.RuleSet;
 import org.apache.calcite.tools.RuleSets;
-import org.apache.calcite.util.ConversionUtil;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.TestUtil;
 import org.apache.calcite.util.Util;
@@ -290,17 +289,6 @@ private static String toSql(RelNode root, SqlDialect dialect,
     sql(query).ok(expected);
   }
 
-  /** Test case for <a href="https://issues.apache.org/jira/browse/CALCITE-6006">[CALCITE-6006]</a>
-   * RelToSqlConverter loses charset information. */
-  @Test void testCharset() {
-    sql("select _UTF8'\u4F60\u597D'")
-        .withMysql() // produces a simpler output query
-        .ok("SELECT _UTF-8'\u4F60\u597D'");
-    sql("select _UTF16'" + ConversionUtil.TEST_UNICODE_STRING + "'")
-        .withMysql()
-        .ok("SELECT _UTF-16LE'" + ConversionUtil.TEST_UNICODE_STRING + "'");
-  }
-
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-4321">[CALCITE-4321]
    * JDBC adapter omits FILTER (WHERE ...) expressions when generating SQL</a>
@@ -1363,6 +1351,30 @@ private static String toSql(RelNode root, SqlDialect dialect,
         .withMysql().ok(expectedMysql);
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-6196">[CALCITE-6196]
+   * Remove OVER requirement for BigQuery PERCENTILE_CONT/DISC</a>. */
+  @Test void testPercentileContFunctionWithoutOver() {
+    final String query = "select percentile_cont(\"product_id\", .5) "
+        + "from \"foodmart\".\"product\"";
+    final String expected = "SELECT PERCENTILE_CONT(product_id, 0.5)\n"
+        + "FROM foodmart.product";
+
+    sql(query).withBigQuery().withLibrary(SqlLibrary.BIG_QUERY).ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-6196">[CALCITE-6196]
+   * Remove OVER requirement for BigQuery PERCENTILE_CONT/DISC</a>. */
+  @Test void testPercentileDiscFunctionWithoutOver() {
+    final String query = "select percentile_disc(\"product_id\", .5) "
+        + "from \"foodmart\".\"product\"";
+    final String expected = "SELECT PERCENTILE_DISC(product_id, 0.5)\n"
+        + "FROM foodmart.product";
+
+    sql(query).withBigQuery().withLibrary(SqlLibrary.BIG_QUERY).ok(expected);
+  }
+
   /** As {@link #testSum0BecomesCoalesce()} but for windowed aggregates. */
   @Test void testWindowedSum0BecomesCoalesce() {
     final String query = "select\n"
@@ -2117,8 +2129,9 @@ private SqlDialect nonOrdinalDialect() {
     // case4: wrap collation's info to numeric constant - rewrite it.
     relFn(relFn)
         .ok("SELECT \"JOB\", \"ENAME\"\n"
+            + "FROM (SELECT 1 AS \"$f0\", \"ENAME\", \"JOB\", '23' AS \"$f3\", 12 AS \"col1\", 34 AS \"$f5\"\n"
             + "FROM \"scott\".\"EMP\"\n"
-            + "ORDER BY '1', '23', '12', \"ENAME\", '34' DESC NULLS LAST")
+            + "ORDER BY 1, 4, 5, \"ENAME\", 6 DESC NULLS LAST) AS \"t0\"")
         .dialect(nonOrdinalDialect())
         .ok("SELECT JOB, ENAME\n"
             + "FROM scott.EMP\n"
@@ -2351,6 +2364,33 @@ private SqlDialect nonOrdinalDialect() {
     sql(parseDatetime).withLibrary(SqlLibrary.BIG_QUERY).ok(expectedParseDatetime);
   }
 
+  @Test void testBigQueryDatetimeDiffFunctions() {
+    final String timeDiff = "select time_diff(time '15:30:00', time '14:35:00', minute)\n"
+        + "from \"foodmart\".\"product\"\n";
+    final String expectedTimeDiff = "SELECT TIME_DIFF(TIME '15:30:00', TIME '14:35:00', MINUTE)\n"
+        + "FROM foodmart.product";
+
+    final String dateDiff = "select date_diff(date '2010-07-07', date '2008-12-25', day)\n"
+        + "from \"foodmart\".\"product\"\n";
+    final String expectedDateDiff = "SELECT DATE_DIFF(DATE '2010-07-07', DATE '2008-12-25', DAY)\n"
+        + "FROM foodmart.product";
+
+    final String timestampDiff =
+        "select timestamp_diff(timestamp '2010-07-07 10:20:00', timestamp '2008-12-25 15:30:00', "
+            + "day)\n"
+        + "from \"foodmart\".\"product\"\n";
+    final String expectedtimestampDiff =
+        "SELECT TIMESTAMP_DIFF(TIMESTAMP '2010-07-07 10:20:00', TIMESTAMP '2008-12-25 15:30:00', "
+            + "DAY)\n"
+        + "FROM foodmart.product";
+
+
+    final Sql sql = fixture().withBigQuery().withLibrary(SqlLibrary.BIG_QUERY);
+    sql.withSql(timeDiff).ok(expectedTimeDiff);
+    sql.withSql(dateDiff).ok(expectedDateDiff);
+    sql.withSql(timestampDiff).ok(expectedtimestampDiff);
+  }
+
   @Test void testBigQueryTimeTruncFunctions() {
     String timestampTrunc = "select timestamp_trunc(timestamp '2012-02-03 15:30:00', month)\n"
         + "from \"foodmart\".\"product\"\n";
diff --git a/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java b/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
index f363c933a5a..037da07f3e1 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
@@ -189,6 +189,17 @@ static class Fixture extends SqlTypeFixture {
     assertThat(dataType, is(innerType));
   }
 
+  /** <a href="https://issues.apache.org/jira/browse/CALCITE-6343">[CALCITE-6343]</a>
+   * Ensure that AS operator doesn't change return type of measures. */
+  @Test void testAsOperatorReturnTypeInferenceDoesNotRemoveMeasure() {
+    final SqlTypeFactoryImpl f = new Fixture().typeFactory;
+    RelDataType innerType = f.createSqlType(SqlTypeName.DOUBLE);
+    RelDataType measureType = f.createMeasureType(innerType);
+    RelDataType dataType =
+        SqlStdOperatorTable.AS.inferReturnType(f, Lists.newArrayList(measureType));
+    assertThat(dataType, is(measureType));
+  }
+
   @Test void testCustomDecimalPlusReturnTypeInference() {
     final SqlTypeFactoryImpl f = new Fixture().customTypeFactory;
     RelDataType operand1 = f.createSqlType(SqlTypeName.DECIMAL, 38, 10);
diff --git a/core/src/test/java/org/apache/calcite/test/ExceptionMessageTest.java b/core/src/test/java/org/apache/calcite/test/ExceptionMessageTest.java
index 31b09ba75b8..b70a011713a 100644
--- a/core/src/test/java/org/apache/calcite/test/ExceptionMessageTest.java
+++ b/core/src/test/java/org/apache/calcite/test/ExceptionMessageTest.java
@@ -217,7 +217,7 @@ private void runQuery(Function<RelBuilder, RelNode> relFn) throws SQLException {
           + "LogicalProject($f0=[ABS($1)])\n"
           + "  LogicalTableScan(table=[[test, entries]])\n"
           + "]";
-      assertThat(e.getMessage(), Matchers.isLinux(message));
+      assertThat(e.getMessage(), containsString(message));
     }
   }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/JdbcTest.java b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
index 023a57ef6b3..0ef40a58f6a 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
@@ -6104,11 +6104,11 @@ private CalciteAssert.AssertThat modelWithView(String view,
         try (ResultSet r =
                  metaData.getColumns(null, "adhoc", "V", null)) {
           assertEquals(
-              "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=empid; DATA_TYPE=4; TYPE_NAME=JavaType(int) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=1; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n"
-                  + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=deptno; DATA_TYPE=4; TYPE_NAME=JavaType(int) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=2; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n"
-                  + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=name; DATA_TYPE=12; TYPE_NAME=JavaType(class java.lang.String); COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=1; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=3; IS_NULLABLE=YES; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n"
-                  + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=salary; DATA_TYPE=7; TYPE_NAME=JavaType(float) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=4; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n"
-                  + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=commission; DATA_TYPE=4; TYPE_NAME=JavaType(class java.lang.Integer); COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=1; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=5; IS_NULLABLE=YES; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n",
+              "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=empid; DATA_TYPE=4; TYPE_NAME=JavaType(int) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=1; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=NO; IS_GENERATEDCOLUMN=NO\n"
+                  + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=deptno; DATA_TYPE=4; TYPE_NAME=JavaType(int) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=2; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=NO; IS_GENERATEDCOLUMN=NO\n"
+                  + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=name; DATA_TYPE=12; TYPE_NAME=JavaType(class java.lang.String); COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=1; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=3; IS_NULLABLE=YES; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=NO; IS_GENERATEDCOLUMN=NO\n"
+                  + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=salary; DATA_TYPE=7; TYPE_NAME=JavaType(float) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=4; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=NO; IS_GENERATEDCOLUMN=NO\n"
+                  + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=commission; DATA_TYPE=4; TYPE_NAME=JavaType(class java.lang.Integer); COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=1; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=5; IS_NULLABLE=YES; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=NO; IS_GENERATEDCOLUMN=NO\n",
               CalciteAssert.toString(r));
         }
 
diff --git a/core/src/test/java/org/apache/calcite/test/SqlOperatorUnparseTest.java b/core/src/test/java/org/apache/calcite/test/SqlOperatorUnparseTest.java
index 645642068bc..08f4504e833 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlOperatorUnparseTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlOperatorUnparseTest.java
@@ -113,4 +113,10 @@ void testSafeOffsetOperator() {
   void testContainsSubstrFunc() {
     super.testContainsSubstrFunc();
   }
+
+  @Override @Disabled("https://issues.apache.org/jira/browse/CALCITE-6002"
+      + "Customize handling of DateTimeTypeName based on type system")
+  void testLiteralAtLimit() {
+    super.testLiteralAtLimit();
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java b/core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java
index e62eeb78b56..6640d674b40 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java
@@ -4756,6 +4756,22 @@ void checkUserDefinedOrderByOver(NullCollation nullCollation) {
         .ok();
   }
 
+  /** Regression test for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-6343">[CALCITE-6343]
+   * AS alias operator stripping MEASUREness from measures</a>.
+   */
+  @Test void testMeasureRefWithAlias() {
+    final String sql = "select count_plus_100 as c\n"
+        + "from empm";
+    fixture()
+        .withFactory(c ->
+            c.withOperatorTable(t ->
+              SqlValidatorTest.operatorTableFor(SqlLibrary.CALCITE)))
+        .withCatalogReader(MockCatalogReaderExtended::create)
+        .withSql(sql)
+        .ok();
+  }
+
   /** Test case for:
    * <a href="https://issues.apache.org/jira/browse/CALCITE-6013">[CALCITE-6013]
    * Unnecessary measures added as projects during rel construction</a>.
@@ -5281,4 +5297,24 @@ void checkUserDefinedOrderByOver(NullCollation nullCollation) {
     String sql = "SELECT CAST(CAST(? AS INTEGER) AS CHAR)";
     sql(sql).ok();
   }
+
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5508">DATETIME and TIMESTAMP constructor
+   * functions</a> that take single arguments with the same type as the function's return type.
+   *
+   * <p>The function counts as a no-op in this case.
+   */
+  @Test void testNoOpTimeDateFunctions() {
+    String sql = "SELECT TIMESTAMP(TIMESTAMP WITH LOCAL TIME ZONE '2023-12-21 12:34:56'), "
+        + "DATETIME(TIMESTAMP '2023-12-21 12:34:56') "
+        + "FROM emp";
+
+    fixture()
+        .withFactory(c ->
+            c.withOperatorTable(t ->
+                SqlValidatorTest.operatorTableFor(SqlLibrary.BIG_QUERY)))
+        .withSql(sql)
+        .ok();
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
index 4b5ffd63d13..386231272af 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
@@ -11837,10 +11837,10 @@ private void checkCustomColumnResolving(String table) {
             + "  where empno = 1)\n"
             + "where j = 'doctor'")
         .ok();
-      // Deceitful alias #2. Filter on 'job' is a filter on the underlying
-      // 'ename', so the underlying 'job' is missing a filter.
+    // Deceitful alias #2. Filter on 'job' is a filter on the underlying
+    // 'slacker', so the underlying 'job' is missing a filter.
     fixture.withSql("^select * from (\n"
-            + "  select job as j, ename as job\n"
+            + "  select job as j, slacker as job\n"
             + "  from emp\n"
             + "  where empno = 1)\n"
             + "where job = 'doctor'^")
@@ -11988,6 +11988,352 @@ private void checkCustomColumnResolving(String table) {
             + "where empno = 1\n"
             + "and job = 'doctor'")
         .ok();
+    fixture.withSql("WITH cte AS (\n"
+            + "  select * from emp where empno = 1)\n"
+            + "SELECT *\n"
+            + "from cte\n"
+            + "where job = 'doctor'")
+        .ok();
+    fixture.withSql("WITH cte AS (\n"
+            + "  select empno, job from emp)\n"
+            + "SELECT *\n"
+            + "from cte\n"
+            + "where empno = 1\n"
+            + "and job = 'doctor'")
+        .ok();
+
+    // Filters are missing on EMPNO and JOB, but the error message only
+    // complains about JOB because EMPNO is in the SELECT clause, and could
+    // theoretically be filtered by an enclosing query.
+    fixture.withSql("^select empno\n"
+            + "from emp^")
+        .fails(missingFilters("JOB"));
+    fixture.withSql("^select empno,\n"
+            + "  sum(sal) over (order by mgr)\n"
+            + "from emp^")
+        .fails(missingFilters("JOB"));
+  }
+
+  /**
+   * Tests validation of must-filter columns with the inclusion of bypass fields.
+   *
+   * <p>If a table that implements
+   * {@link org.apache.calcite.sql.validate.SemanticTable} tags fields as
+   * 'must-filter', and the SQL query does not contain a WHERE or HAVING clause
+   * on each of the tagged columns, the validator should throw an error.
+   * If any bypass field for a table is in a WHERE/HAVING clause for that SELECT statement,
+   * the must-filter requirements for that table are disabled.
+   */
+  @Test void testMustFilterColumnsWithBypass() {
+    final SqlValidatorFixture fixture = fixture()
+        .withParserConfig(c -> c.withQuoting(Quoting.BACK_TICK))
+        .withOperatorTable(operatorTableFor(SqlLibrary.BIG_QUERY))
+        .withCatalogReader(MustFilterMockCatalogReader::create);
+    // Basic query
+    fixture.withSql("select empno\n"
+            + "from emp\n"
+            + "where job = 'doctor'\n"
+            + "and empno = 1")
+        .ok();
+    fixture.withSql("^select *\n"
+            + "from emp\n"
+            + "where concat(emp.empno, ' ') = 'abc'^")
+        .fails(missingFilters("JOB"));
+
+    // ENAME is a bypass field
+    fixture.withSql("select *\n"
+            + "from emp\n"
+            + "where concat(emp.ename, ' ') = 'abc'^")
+        .ok();
+
+    // SUBQUERIES
+    fixture.withSql("select * from (\n"
+            + "  select * from emp where empno = 1)\n"
+            + "where job = 'doctor'")
+        .ok();
+    fixture.withSql("^select * from (\n"
+            + "  select ename from emp where empno = 1)^")
+        .fails(missingFilters("JOB"));
+    fixture.withSql("select * from (\n"
+            + "  select job, ename from emp where empno = 1)"
+            + "where ename = '1'")
+        .ok();
+    fixture.withSql("select * from (\n"
+            + "  select empno, job from emp)\n"
+            + "where job = 'doctor' and empno = 1")
+        .ok();
+
+    // Deceitful alias #1. Filter on 'j' is a filter on the underlying 'job'.
+    fixture.withSql("select * from (\n"
+            + "  select job as j, ename as job\n"
+            + "  from emp\n"
+            + "  where empno = 1)\n"
+            + "where j = 'doctor'")
+        .ok();
+
+    // Deceitful alias #2. Filter on 'job' is a filter on the underlying
+    // 'slacker', so the underlying 'job' is missing a filter.
+    fixture.withSql("^select * from (\n"
+            + "  select job as j, slacker as job\n"
+            + "  from emp\n"
+            + "  where empno = 1)\n"
+            + "where job = 'doctor'^")
+        .fails(missingFilters("J"));
+
+    // Deceitful alias #3. Filter on 'job' is a filter on the underlying
+    // 'ename', which is a bypass field thus no exception.
+    fixture.withSql("select * from (\n"
+            + "  select job as j, ename as job\n"
+            + "  from emp\n"
+            + "  where empno = 1)\n"
+            + "where job = 'doctor'^")
+        .ok();
+    fixture.withSql("select * from (\n"
+            + "  select * from emp where job = 'doctor')\n"
+            + "where empno = 1")
+        .ok();
+    fixture.withSql("select * from (\n"
+            + "  select empno from emp where job = 'doctor')\n"
+            + "where empno = 1")
+        .ok();
+    fixture.withSql("^select * from (\n"
+            + "  select * from emp where empno = 1)^")
+        .fails(missingFilters("JOB"));
+
+    // Query is valid because ENAME is a bypass field
+    fixture.withSql("select * from (\n"
+            + "  select * from emp where ename = 1)^")
+        .ok();
+    fixture.withSql("^select * from (select * from `SALES`.`EMP`) as a1^ ")
+        .fails(missingFilters("EMPNO", "JOB"));
+    fixture.withSql("select * from (select * from `SALES`.`EMP`) as a1 where ename = '1'^ ")
+        .ok();
+
+    // JOINs
+    fixture.withSql("^select *\n"
+            + "from emp\n"
+            + "join dept on emp.deptno = dept.deptno^")
+        .fails(missingFilters("EMPNO", "JOB", "NAME"));
+
+    // Query is invalid because ENAME is a bypass field for EMP table, but not the DEPT table.
+    fixture.withSql("^select *\n"
+            + "from emp\n"
+            + "join dept on emp.deptno = dept.deptno where ename = '1'^")
+        .fails(missingFilters("NAME"));
+    fixture.withSql("^select *\n"
+            + "from emp\n"
+            + "join dept on emp.deptno = dept.deptno\n"
+            + "where emp.empno = 1^")
+        .fails(missingFilters("JOB", "NAME"));
+    fixture.withSql("select *\n"
+            + "from emp\n"
+            + "join dept on emp.deptno = dept.deptno\n"
+            + "where emp.empno = 1\n"
+            + "and emp.job = 'doctor'\n"
+            + "and dept.name = 'ACCOUNTING'")
+        .ok();
+    fixture.withSql("select *\n"
+            + "from emp\n"
+            + "join dept on emp.deptno = dept.deptno\n"
+            + "where empno = 1\n"
+            + "and job = 'doctor'\n"
+            + "and dept.name = 'ACCOUNTING'")
+        .ok();
+
+    // Self-join
+    fixture.withSql("^select *\n"
+            + "from `SALES`.emp a1\n"
+            + "join `SALES`.emp a2 on a1.empno = a2.empno^")
+        .fails(missingFilters("EMPNO", "EMPNO0", "JOB", "JOB0"));
+
+    // Query is invalid because filtering on a bypass field in a1 disables must-filter for a1,
+    // but a2 must-filters are still required.
+    fixture.withSql("^select *\n"
+            + "from `SALES`.emp a1\n"
+            + "join `SALES`.emp a2 on a1.empno = a2.empno where a1.ename = '1'^")
+            .fails(missingFilters("EMPNO0", "JOB0"));
+
+    // Query is invalid because here are two JOB columns but only one is filtered.
+    fixture.withSql("^select *\n"
+            + "from emp a1\n"
+            + "join emp a2 on a1.empno = a2.empno\n"
+            + "where a2.empno = 1\n"
+            + "and a1.empno = 1\n"
+            + "and a2.job = 'doctor'^")
+        .fails(missingFilters("JOB"));
+    fixture.withSql("select *\n"
+            + "from emp a1\n"
+            + "join emp a2 on a1.empno = a2.empno\n"
+            + "where a2.empno = 1\n"
+            + "and a1.empno = 1\n"
+            + "and a2.job = 'doctor'^\n"
+            + "and a1.ename = '1'")
+        .ok();
+    fixture.withSql("select *\n"
+            + "from emp a1\n"
+            + "join emp a2 on a1.empno = a2.empno\n"
+            + "where a1.empno = 1\n"
+            + "and a1.job = 'doctor'\n"
+            + "and a2.empno = 2\n"
+            + "and a2.job = 'undertaker'\n")
+        .ok();
+    fixture.withSql("^select *\n"
+            + " from (select * from `SALES`.`EMP`) as a1\n"
+            + "join (select * from `SALES`.`EMP`) as a2\n"
+            + "  on a1.`EMPNO` = a2.`EMPNO`^")
+        .fails(missingFilters("EMPNO", "EMPNO0", "JOB", "JOB0"));
+
+    // Query is invalid because filtering on a bypass field in a1 disables must-filter for a1,
+    // but a2 must-filters are still required.
+    fixture.withSql("^select *\n"
+            + " from (select * from `SALES`.`EMP`) as a1\n"
+            + "join (select * from `SALES`.`EMP`) as a2\n"
+            + "  on a1.`EMPNO` = a2.`EMPNO`\n"
+            + "where a1.ename = '1'^")
+        .fails(missingFilters("EMPNO0", "JOB0"));
+    fixture.withSql("^select *\n"
+            + " from (select * from `SALES`.`EMP` where `ENAME` = '1') as a1\n"
+            + "join (select * from `SALES`.`EMP`) as a2\n"
+            + "  on a1.`EMPNO` = a2.`EMPNO`^")
+        .fails(missingFilters("EMPNO0", "JOB0"));
+
+    // USING
+    fixture.withSql("^select *\n"
+            + "from emp\n"
+            + "join dept using(deptno)\n"
+            + "where emp.empno = 1^")
+        .fails(missingFilters("JOB", "NAME"));
+
+    // Query is invalid because ENAME is bypass field for EMP, but not for DEPT.
+    fixture.withSql("^select *\n"
+            + "from emp\n"
+            + "join dept using(deptno)\n"
+            + "where emp.ename = '1'^")
+        .fails(missingFilters("NAME"));
+    fixture.withSql("select *\n"
+            + "from emp\n"
+            + "join dept using(deptno)\n"
+            + "where emp.empno = 1\n"
+            + "and emp.job = 'doctor'\n"
+            + "and dept.name = 'ACCOUNTING'")
+        .ok();
+
+    // GROUP BY (HAVING)
+    fixture.withSql("select *\n"
+            + "from dept\n"
+            + "group by deptno, name\n"
+            + "having name = 'accounting_dept'")
+        .ok();
+    fixture.withSql("^select *\n"
+            + "from dept\n"
+            + "group by deptno, name^")
+        .fails(missingFilters("NAME"));
+
+    // Query is valid because DEPTNO is bypass field.
+    fixture.withSql("select *\n"
+            + "from dept\n"
+            + "group by deptno, name\n"
+            + "having deptno > '1'")
+        .ok();
+    fixture.withSql("select name\n"
+            + "from dept\n"
+            + "group by name\n"
+            + "having name = 'accounting'")
+        .ok();
+    fixture.withSql("^select name\n"
+            + "from dept\n"
+            + "group by name^ ")
+        .fails(missingFilters("NAME"));
+    fixture.withSql("select sum(sal)\n"
+            + "from emp\n"
+            + "where empno > 10\n"
+            + "and job = 'doctor'\n"
+            + "group by empno\n"
+            + "having sum(sal) > 100")
+        .ok();
+    fixture.withSql("^select sum(sal)\n"
+            + "from emp\n"
+            + "where empno > 10\n"
+            + "group by empno\n"
+            + "having sum(sal) > 100^")
+        .fails(missingFilters("JOB"));
+    fixture.withSql("^select sum(sal)\n"
+            + "from emp\n"
+            + "where empno > 10\n"
+            + "group by empno\n"
+            + "having sum(sal) > 100^")
+        .fails(missingFilters("JOB"));
+    fixture.withSql("select sum(sal), job\n"
+            + "from emp\n"
+            + "where empno > 10\n"
+            + "group by job\n"
+            + "having job = 'undertaker'")
+        .ok();
+    fixture.withSql("select sum(sal), ename\n"
+            + "from emp\n"
+            + "where empno > 10\n"
+            + "group by empno, ename\n"
+            + "having ename = '1'")
+        .ok();
+    fixture.withSql("select sum(sal)\n"
+            + "from emp\n"
+            + "where ename = '1'\n"
+            + "group by empno, ename\n"
+            + "having sum(sal) > 100")
+        .ok();
+
+    // CTE
+    fixture.withSql("^WITH cte AS (\n"
+            + "  select * from emp order by empno)^\n"
+            + "SELECT * from cte")
+        .fails(missingFilters("EMPNO", "JOB"));
+
+    // Query is valid because ENAME is a bypass field.
+    fixture.withSql("WITH cte AS (\n"
+            + "  select * from emp where ename = '1' order by empno)^\n"
+            + "SELECT * from cte")
+        .ok();
+
+    // Query is valid because ENAME is a bypass field.
+    fixture.withSql("WITH cte AS (\n"
+        + "  select * from emp order by empno)^\n"
+        + "SELECT * from cte where ename = '1'")
+        .ok();
+    fixture.withSql("^WITH cte AS (\n"
+            + "  select * from emp where empno = 1)^\n"
+            + "SELECT * from cte")
+        .fails(missingFilters("JOB"));
+    fixture.withSql("WITH cte AS (\n"
+            + "  select *\n"
+            + "  from emp\n"
+            + "  where empno = 1\n"
+            + "  and job = 'doctor')\n"
+            + "SELECT * from cte")
+        .ok();
+    fixture.withSql("^WITH cte AS (\n"
+            + "  select * from emp)^\n"
+            + "SELECT *\n"
+            + "from cte\n"
+            + "where empno = 1")
+        .fails(missingFilters("JOB"));
+    fixture.withSql("WITH cte AS (\n"
+            + "  select * from emp where ename = '1')^\n"
+            + "SELECT *\n"
+            + "from cte\n")
+        .ok();
+    fixture.withSql("WITH cte AS (\n"
+            + "  select * from emp)^\n"
+            + "SELECT *\n"
+            + "from cte\n"
+            + "where ename = '1'")
+        .ok();
+    fixture.withSql("WITH cte AS (\n"
+            + "  select * from emp)\n"
+            + "SELECT *\n"
+            + "from cte\n"
+            + "where empno = 1\n"
+            + "and job = 'doctor'")
+        .ok();
     fixture.withSql("WITH cte AS (\n"
         + "  select * from emp where empno = 1)\n"
         + "SELECT *\n"
@@ -12002,9 +12348,9 @@ private void checkCustomColumnResolving(String table) {
             + "and job = 'doctor'")
         .ok();
 
-    // Filters are missing on EMPNO and JOB, but the error message only
-    // complains about JOB because EMPNO is in the SELECT clause, and could
-    // theoretically be filtered by an enclosing query.
+    // Query is invalid because filters are missing on EMPNO and JOB.
+    // The error message only complains about JOB because EMPNO is in the SELECT clause,
+    // and could theoretically be filtered by an enclosing query.
     fixture.withSql("^select empno\n"
             + "from emp^")
         .fails(missingFilters("JOB"));
diff --git a/core/src/test/java/org/apache/calcite/test/UdtTest.java b/core/src/test/java/org/apache/calcite/test/UdtTest.java
index 970a40a0b78..cf93788a9c9 100644
--- a/core/src/test/java/org/apache/calcite/test/UdtTest.java
+++ b/core/src/test/java/org/apache/calcite/test/UdtTest.java
@@ -29,6 +29,14 @@ private CalciteAssert.AssertThat withUdt() {
         + "     {\n"
         + "       name: 'foo',\n"
         + "       type: 'BIGINT'\n"
+        + "     },\n"
+        + "     {\n"
+        + "       name: 'TIMESTAMP',\n"
+        + "       type: 'TIMESTAMP_WITH_LOCAL_TIME_ZONE'\n"
+        + "     },\n"
+        + "     {\n"
+        + "       name: 'DATETIME',\n"
+        + "       type: 'TIMESTAMP'\n"
         + "     }"
         + "   ],\n"
         + "   schemas: [\n"
@@ -71,6 +79,15 @@ private CalciteAssert.AssertThat withUdt() {
     withUdt().query(sql).returns("LD=1\n");
   }
 
+  @Test void testAliasOnBasicType() {
+    final String sql1 = "select CAST(\"date\" AS TIMESTAMP) as ts "
+        + "from (VALUES ROW(DATE '2020-12-25', 'SameName')) AS \"t\" (\"date\", \"desc\")";
+    final String sql2 = "select CAST(\"date\" AS DATETIME) as ts "
+        + "from (VALUES ROW(DATE '2020-12-25', 'SameName')) AS \"t\" (\"date\", \"desc\")";
+    withUdt().query(sql1).typeIs("[TS TIMESTAMP_WITH_LOCAL_TIME_ZONE NOT NULL]");
+    withUdt().query(sql2).typeIs("[TS TIMESTAMP NOT NULL]");
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-3045">[CALCITE-3045]
    * NullPointerException when casting null literal to composite user defined type</a>. */
diff --git a/core/src/test/java/org/apache/calcite/util/SourceTest.java b/core/src/test/java/org/apache/calcite/util/SourceTest.java
index 4f4f775ebf2..90c8759e193 100644
--- a/core/src/test/java/org/apache/calcite/util/SourceTest.java
+++ b/core/src/test/java/org/apache/calcite/util/SourceTest.java
@@ -15,8 +15,13 @@
  * limitations under the License.
  */
 package org.apache.calcite.util;
+
+import org.apache.commons.lang3.StringUtils;
+
 import com.google.common.io.CharSource;
 
+import net.hydromatic.foodmart.queries.FoodmartQuerySet;
+
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -25,13 +30,18 @@
 
 import java.io.BufferedReader;
 import java.io.File;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
 import java.io.Reader;
+import java.net.MalformedURLException;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
 import static org.apache.calcite.util.Sources.file;
@@ -39,6 +49,8 @@
 import static org.apache.calcite.util.Sources.url;
 
 import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.hasToString;
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -118,6 +130,51 @@ void testAbsoluteFileToUrl(String path, String expectedUrl) throws URISyntaxExce
         () -> "Sources.of(Sources.of(file(" + path + ").absolutePath).url()).file().getPath()");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5052">[CALCITE-5052]
+   * Allow Source based on a URL with jar: protocol</a>. */
+  @Test void testJarFileUrl() throws MalformedURLException {
+    // mock jar file
+    final String jarPath = "jar:file:sources!/abcdef.txt";
+    final URL url = new URL(jarPath);
+    final Source source = of(url);
+    assertThat("No file retrieved for Sources.of(file " + jarPath + ")",
+        source.file(), notNullValue());
+    assertThat("Sources.of(file " + jarPath + ").url()).file().getPath()",
+        slashify(source.file().getPath()),
+        is("sources!/abcdef.txt"));
+
+  }
+
+  /** Tests {@link Sources#of(URL)} with code similar to
+   * {@code DiffRepository.Key#toRepo()}. */
+  @Test void testJarFileUrlWrite() {
+    final URL refFile = FoodmartQuerySet.class.getResource("/queries.json");
+    assertThat(refFile, notNullValue());
+    final Source source = of(refFile);
+    final String refFilePath = source.file().getAbsolutePath();
+    final String logFilePath;
+    assertThat(StringUtils.containsIgnoreCase(refFilePath, ".jar!"), is(true));
+    // If the file is located in a JAR, we cannot write the file in place
+    // so we add it to the /tmp directory
+    // the expected output is /tmp/[jarname]/[path-to-file-in-jar/filename]_actual.json
+    logFilePath =
+        Pattern.compile(".*\\/(.*)\\.jar\\!(.*)\\.json")
+            .matcher(refFilePath)
+            .replaceAll("/tmp/$1$2_actual.json");
+    final File logFile = new File(logFilePath);
+    assertThat(refFile, not(is(logFile.getAbsolutePath())));
+    boolean b = logFile.getParentFile().mkdirs();
+    Util.discard(b);
+    try (FileOutputStream fos = new FileOutputStream(logFile);
+        OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
+        PrintWriter pw = new PrintWriter(osw)) {
+      pw.println("hello, world!");
+    } catch (IOException e) {
+      throw Util.throwAsRuntime(e);
+    }
+  }
+
   @Test void testAppendWithSpaces() {
     String fooRelative = "fo o+";
     String fooAbsolute = ROOT_PREFIX + "fo o+";
diff --git a/core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml b/core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml
index 1bf1556aa7a..17f6bdaa829 100644
--- a/core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml
+++ b/core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml
@@ -4572,6 +4572,18 @@ group by deptno]]>
 LogicalAggregate(group=[{0}], C=[AGGREGATE($1)])
   LogicalProject(DEPTNO=[$7], COUNT_PLUS_100=[$9])
     LogicalTableScan(table=[[CATALOG, SALES, EMPM]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testMeasureRefWithAlias">
+    <Resource name="sql">
+      <![CDATA[select count_plus_100 as c
+from empm]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(C=[$9])
+  LogicalTableScan(table=[[CATALOG, SALES, EMPM]])
 ]]>
     </Resource>
   </TestCase>
@@ -4937,6 +4949,17 @@ LogicalProject(SKILL=[ROW($0)])
   LogicalFilter(condition=[=($0, '')])
     LogicalProject(TYPE=[$0.TYPE])
       LogicalTableScan(table=[[CATALOG, SALES, DEPT_SINGLE]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testNoOpTimeDateFunctions">
+    <Resource name="sql">
+      <![CDATA[SELECT TIMESTAMP(TIMESTAMP WITH LOCAL TIME ZONE '2023-12-21 12:34:56'), DATETIME(TIMESTAMP '2023-12-21 12:34:56') FROM emp]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EXPR$0=[TIMESTAMP(2023-12-21 12:34:56:TIMESTAMP_WITH_LOCAL_TIME_ZONE(0))], EXPR$1=[DATETIME(2023-12-21 12:34:56)])
+  LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/PredicateAnalyzer.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/PredicateAnalyzer.java
index 9b9796857ca..5c42ac26113 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/PredicateAnalyzer.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/PredicateAnalyzer.java
@@ -25,6 +25,7 @@
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexVisitorImpl;
+import org.apache.calcite.sql.SqlInternalOperator;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlSyntax;
 import org.apache.calcite.sql.type.SqlTypeFamily;
@@ -172,6 +173,15 @@ private static boolean supportedRexCall(RexCall call) {
           return false;
         }
       case FUNCTION:
+      case INTERNAL:
+        if (call.getOperator() instanceof SqlInternalOperator) {
+          switch (call.getKind()) {
+          case SEARCH:
+            return canBeTranslatedToTermsQuery(call);
+          default:
+            return false;
+          }
+        }
         return true;
       case POSTFIX:
         switch (call.getKind()) {
@@ -188,13 +198,6 @@ private static boolean supportedRexCall(RexCall call) {
         default:
           return false;
         }
-      case INTERNAL:
-        switch (call.getKind()) {
-        case SEARCH:
-          return canBeTranslatedToTermsQuery(call);
-        default:
-          return false;
-        }
       case FUNCTION_ID:
       case FUNCTION_STAR:
       default:
@@ -248,8 +251,6 @@ static boolean isSearchWithComplementedPoints(RexCall search) {
         return postfix(call);
       case PREFIX:
         return prefix(call);
-      case INTERNAL:
-        return binary(call);
       case SPECIAL:
         switch (call.getKind()) {
         case CAST:
@@ -267,6 +268,10 @@ static boolean isSearchWithComplementedPoints(RexCall search) {
           throw new PredicateAnalyzerException(message);
         }
       case FUNCTION:
+      case INTERNAL:
+        if (call.getOperator() instanceof SqlInternalOperator) {
+          return binary(call);
+        }
         if (call.getOperator().getName().equalsIgnoreCase("CONTAINS")) {
           List<Expression> operands = visitList(call.getOperands());
           String query =
diff --git a/gradle.properties b/gradle.properties
index d63809f77f8..d1d551fb3f3 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -27,7 +27,7 @@ systemProp.org.gradle.internal.publish.checksums.insecure=true
 # This is version for Calcite itself
 # Note: it should not include "-SNAPSHOT" as it is automatically added by build.gradle.kts
 # Release version can be generated by using -Prelease or -Prc=<int> arguments
-calcite.version=1.37.0
+calcite.version=1.36.10-looker
 # This is a version to be used from Maven repository. It can be overridden by localAvatica below
 calcite.avatica.version=1.25.0
 
diff --git a/looker-release.sh b/looker-release.sh
new file mode 100755
index 00000000000..2d57ed9f8d7
--- /dev/null
+++ b/looker-release.sh
@@ -0,0 +1,98 @@
+#!/bin/bash
+#
+# 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.
+#
+
+# HOW TO RELEASE the Looker fork of Calcite:
+#
+# 1. Start working off the current fork branch: https://github.com/looker-open-source/calcite/tree/looker
+#    `git fetch git@github.com:looker-open-source/calcite.git looker && git checkout FETCH_HEAD`
+# 2. Do whatever needs to be done (rebase on trunk, cherry-pick, remove fixups, etc.),
+#    but don't bother updating the `calcite.version` line in `gradle.properties`.
+#    There should only be "business logic" commits,
+#    and every commit that is not yet upstreamed (called "fix-up" commits)
+#    should reference a Calcite Jira ticket in its message,
+#    and have a PR open to upstream it to Apache's main repo, if possible.
+# 3. Once the code looks good and your Git working directory is clean, run this script
+#    which will do all of this (mostly) automatically:
+#    a) Pull all Looker Calcite version tags from GitHub and show you what the latest one is.
+#       This is just for convenience.
+#    b) Ask you what the next version number should be.
+#       The major number should always be whatever's in Apache's `main` branch.
+#       The minor number should probably be 1 less than whatever's in Apache's `main` branch.
+#       Increment the patch number when you make backward compatible bug fixes.
+#       Generally, we just increment the patch number.
+#    c) Reset your local `looker` branch to the current HEAD.
+#    d) Update the version line in `gradle.properties` and create a version bump commit.
+#    e) Create a release tag pointing to the new version bump commit.
+#    f) Provide you with the commands to push your new branch and tag to GitHub,
+#       and publish release artifacts to Nexus.
+#       This script only automates local changes by design; double-check everything before pushing.
+
+echo "Fetching all tags from looker-open-source repo..." >&2
+git fetch git@github.com:looker-open-source/calcite.git --tags && (
+
+  echo -e "\nLatest Looker release tag was '$(git tag --list | grep -E '^calcite-[0-9]+(\.[0-9]+)*-looker$' | sort --version-sort --reverse | head --lines=1)'" >&2
+  echo "What should the next version be called?" >&2
+  read -p "Input just the numbers and dots (do not include 'calcite-' or '-looker'): " NEXT_NUMBER
+  export NEXT_VERSION="${NEXT_NUMBER}-looker"
+  export NEXT_TAG="calcite-${NEXT_VERSION}"
+
+  echo -e "\nSetting version number in gradle.properties to '$NEXT_VERSION'." >&2
+  # MacOS uses BSD sed, which works differently from GNU sed on Linux.
+  if [[ "$(uname -s)" == "Darwin" ]]
+  then
+    # https://stackoverflow.com/questions/5694228/sed-in-place-flag-that-works-both-on-mac-bsd-and-linux
+    # https://stackoverflow.com/questions/64373364/how-to-fix-sed-command-on-macos-with-error-extra-characters-after-at-the-end-o
+    sed -i.bak "/^calcite\\.version=.*/c\\
+calcite.version=$NEXT_VERSION
+" gradle.properties && rm gradle.properties.bak
+  else
+    sed -i "/^calcite\\.version=.*/c\\calcite.version=$NEXT_VERSION" gradle.properties
+  fi
+
+  # $(exit $?) has the same status code as the previous `sed` command.
+  $(exit $?) && (
+
+    echo -e "\nBuilding '$NEXT_VERSION'..." >&2
+    ./gradlew build -x :redis:test && (
+
+      export LOOKER_COMMIT="$(git rev-parse --short HEAD)"
+
+      export COMMIT_MSG="Prepare for $NEXT_TAG release"
+      echo -e "\nTests passed! Creating commit '$COMMIT_MSG'." >&2
+      git add gradle.properties && git commit -m "$COMMIT_MSG" && (
+
+        echo -e "\nCreating new tag '$NEXT_TAG'." >&2
+        git tag -f "$NEXT_TAG"
+
+        echo -e "\nTake a look around." >&2
+        echo -e "You should see (starting from the most recent tip of your history):" >&2
+        echo -e "- A tagged release commit, which just updates the version and nothing else." >&2
+        echo -e "  There should be only 1 such commit in the whole history." >&2
+        echo -e "- The latest fixup commit (business logic that is not upstreamed)." >&2
+        echo -e "  This becomes the new tip of the looker branch." >&2
+        echo -e "- Prior fixups, if any..." >&2
+        echo -e "- All commits from upstream..." >&2
+        echo -e "\nIf everything looks good, you can publish to Nexus with this command:\n" >&2
+        echo -e "    ./gradlew -Prelease -PskipSign publishAllPublicationsToLookerNexusRepository\n" >&2
+        echo -e "And you can push the release tag and force-push the looker branch to looker-open-source with these commands:\n" >&2
+        echo -e "    git push git@github.com:looker-open-source/calcite.git $NEXT_TAG"
+        echo -e "    git push -f git@github.com:looker-open-source/calcite.git $LOOKER_COMMIT:looker"
+      )
+    )
+  )
+)
diff --git a/looker-snapshot.sh b/looker-snapshot.sh
new file mode 100755
index 00000000000..63b37ca66f2
--- /dev/null
+++ b/looker-snapshot.sh
@@ -0,0 +1,43 @@
+#!/bin/sh
+#
+# 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.
+#
+
+# $1 is the sub-project directory
+# $2 is the artifact ID
+# $3 is the version
+function snapshot_upload {
+    mvn deploy:deploy-file \
+        -DgroupId=org.apache.calcite \
+        -DartifactId="$2" \
+        -Dversion="$3" \
+        -Dpackaging=jar \
+        -Dfile="./$1/build/libs/$2-$3.jar" \
+        -DgeneratePom=false \
+        -DpomFile="./$1/build/publications/$1/pom-default.xml" \
+        -DrepositoryId=nexus \
+        -Durl=https://nexusrepo.looker.com/repository/maven-snapshots/
+}
+
+./gradlew build -x :redis:test && ./gradlew jar && ./gradlew generatePom && (
+    VERSION="$(sed -n 's/^calcite\.version=\([^ ]*\).*/\1/p' gradle.properties)-SNAPSHOT"
+    snapshot_upload core calcite-core "$VERSION"
+    snapshot_upload babel calcite-babel "$VERSION"
+    snapshot_upload linq4j calcite-linq4j "$VERSION"
+    snapshot_upload testkit calcite-testkit "$VERSION"
+    echo
+    echo "Done uploading version ${VERSION} to Looker Nexus Snapshots!"
+)
diff --git a/looker-upload-artifact-registry.sh b/looker-upload-artifact-registry.sh
new file mode 100755
index 00000000000..0881972192d
--- /dev/null
+++ b/looker-upload-artifact-registry.sh
@@ -0,0 +1,43 @@
+#!/bin/sh
+#
+# 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.
+#
+
+# $1 is the sub-project directory
+# $2 is the artifact ID
+# $3 is the version
+function artifact_registry_upload {
+    mvn deploy:deploy-file \
+        -DgroupId=org.apache.calcite \
+        -DartifactId="$2" \
+        -Dversion="$3" \
+        -Dpackaging=jar \
+        -Dfile="./$1/build/libs/$2-$3.jar" \
+        -DgeneratePom=false \
+        -DpomFile="./$1/build/publications/$1/pom-default.xml" \
+        -DrepositoryId=artifact-registry \
+        -Durl=https://us-maven.pkg.dev/prow-build-looker/looker-maven-private
+}
+
+./gradlew build -x :redis:test && ./gradlew jar && ./gradlew generatePom && (
+    VERSION="$(sed -n 's/^calcite\.version=\([^ ]*\).*/\1/p' gradle.properties)"
+    artifact_registry_upload core calcite-core "$VERSION"
+    artifact_registry_upload babel calcite-babel "$VERSION"
+    artifact_registry_upload linq4j calcite-linq4j "$VERSION"
+    artifact_registry_upload testkit calcite-testkit "$VERSION"
+    echo
+    echo "Done uploading version ${VERSION} to Looker Artifact Registry!"
+)
diff --git a/looker.md b/looker.md
new file mode 100644
index 00000000000..5cf2f199aae
--- /dev/null
+++ b/looker.md
@@ -0,0 +1,105 @@
+<!--
+{% comment %}
+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.
+{% endcomment %}
+-->
+# Looker's branch of Calcite
+
+This document describes how to develop Looker's branch of Calcite.
+
+Do not merge to Calcite's master branch.
+
+## Development
+
+*Read the instructions* in the `looker-release.sh` script,
+but do not run that script until you're ready to publish a production release.
+
+Looker has poor infrastructure for testing with local builds of Avatica.
+The easiest way is to upload a snapshot version to Looker's Nexus repository and use it.
+To upload a snapshot version, simply run `./looker-snapshot.sh`,
+which runs `./gradlew build` and, if successful,
+uploads the resulting snapshot artifacts to the repo
+using the version number configured in `gradle.properties` (plus a "-SNAPSHOT" suffix).
+
+Then, use that snapshot version in Looker's `internal/repositories/maven_deps.bzl` and repin,
+and you're ready to build.
+
+## Release
+
+Define Looker's Nexus repository in your `~/.gradle/init.gradle.kts`
+file:
+
+```kotlin
+allprojects {
+    plugins.withId("maven-publish") {
+        configure<PublishingExtension> {
+            repositories {
+                maven {
+                    name = "lookerNexus"
+                    val baseUrl = "https://nexusrepo.looker.com"
+                    val releasesUrl = "$baseUrl/repository/maven-releases"
+                    val snapshotsUrl = "$baseUrl/repository/maven-snapshots"
+                    val release = !project.version.toString().endsWith("-SNAPSHOT")
+                    // val release = project.hasProperty("release")
+                    url = uri(if (release) releasesUrl else snapshotsUrl)
+                    credentials {
+                        username = "xxx"
+                        password = "xxx"
+                    }
+                }
+            }
+        }
+    }
+}
+```
+
+In the above fragment, replace the values of the `username` and
+`password` properties with the secret credentials.
+
+*NOTE* This fragment *must* be in a file outside of your git sandbox.
+If the file were in the git sandbox, it would be too easy to
+accidentally commit the secret credentials and expose them on a
+public site.
+
+*Read the instructions* in the `looker-release.sh` script, then run it.
+The script will only make local changes.
+You'll have a chance to review them before pushing anything to Nexus or GitHub.
+
+Each release will have a name like `1.21.1-looker` (if the most
+recent official Calcite release is `1.21`) and have a git tag
+`calcite-1.21.1-looker`.
+
+You should make it from a branch that differs from Calcite's
+`master` branch in only minor ways:
+* Cherry-pick commits from the previous `calcite-x.xx.x-looker`
+  release that set up Looker's repositories (or, if you prefer,
+  rebase the previous release branch onto the latest master)
+* If necessary, include one or two commits for short-term fixes, but
+  log [JIRA cases](https://issues.apache.org/jira/browse/CALCITE) to
+  get them into `master`.
+* Keep fixup commits coherent (squash incremental commits)
+  and to a minimum.
+* The final commit for a release must only set the version
+  in `gradle.properties`, and it must be the only such commit
+  that differs from Calcite trunk. Note that Calcite increments
+  the version in trunk immediately after each release, so
+  that version is typically unreleased. The Looker version
+  should be named after the most recent Calcite release,
+  so the version in trunk is generally decremented
+  while adding the `-looker` suffix.
+
+Check the artifacts
+[on Nexus](https://nexusproxy.looker.com/#browse/search=keyword%3Dorg.apache.calcite).
diff --git a/site/Gemfile.lock b/site/Gemfile.lock
index ba69c6ecaf3..7398d070ad2 100644
--- a/site/Gemfile.lock
+++ b/site/Gemfile.lock
@@ -53,7 +53,7 @@ GEM
     rb-fsevent (0.11.1)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rexml (3.2.5)
+    rexml (3.3.9)
     rouge (3.28.0)
     safe_yaml (1.0.5)
     sassc (2.4.0)
diff --git a/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java b/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
index ae0234fab59..01d445ab633 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
@@ -1783,6 +1783,7 @@ void checkPeriodPredicate(Checker checker) {
         .ok("CEIL((`X` + INTERVAL '1:20' MINUTE TO SECOND) TO MILLENNIUM)");
   }
 
+  @Disabled // [CALCITE-6055] Re-enable this ASAP.
   @Test public void testCast() {
     expr("cast(x as boolean)")
         .ok("CAST(`X` AS BOOLEAN)");
@@ -1801,11 +1802,11 @@ void checkPeriodPredicate(Checker checker) {
     expr("cast(x as time with time zone)")
         .ok("CAST(`X` AS TIME WITH TIME ZONE)");
     expr("cast(x as timestamp without time zone)")
-        .ok("CAST(`X` AS TIMESTAMP)");
+        .ok("CAST(`X` AS `TIMESTAMP`)");
     expr("cast(x as timestamp with local time zone)")
-        .ok("CAST(`X` AS TIMESTAMP WITH LOCAL TIME ZONE)");
+        .ok("CAST(`X` AS `TIMESTAMP WITH LOCAL TIME ZONE`)");
     expr("cast(x as timestamp with time zone)")
-        .ok("CAST(`X` AS TIMESTAMP WITH TIME ZONE)");
+        .ok("CAST(`X` AS `TIMESTAMP TZ`)");
     expr("cast(x as time(0))")
         .ok("CAST(`X` AS TIME(0))");
     expr("cast(x as time(0) without time zone)")
@@ -1813,13 +1814,13 @@ void checkPeriodPredicate(Checker checker) {
     expr("cast(x as time(0) with local time zone)")
         .ok("CAST(`X` AS TIME(0) WITH LOCAL TIME ZONE)");
     expr("cast(x as timestamp(0))")
-        .ok("CAST(`X` AS TIMESTAMP(0))");
+        .ok("CAST(`X` AS `TIMESTAMP`(0))");
     expr("cast(x as timestamp(0) without time zone)")
-        .ok("CAST(`X` AS TIMESTAMP(0))");
+        .ok("CAST(`X` AS `TIMESTAMP`(0))");
     expr("cast(x as timestamp(0) with local time zone)")
-        .ok("CAST(`X` AS TIMESTAMP(0) WITH LOCAL TIME ZONE)");
+        .ok("CAST(`X` AS `TIMESTAMP WITH LOCAL TIME ZONE`(0))");
     expr("cast(x as timestamp)")
-        .ok("CAST(`X` AS TIMESTAMP)");
+        .ok("CAST(`X` AS `TIMESTAMP`)");
     expr("cast(x as decimal(1,1))")
         .ok("CAST(`X` AS DECIMAL(1, 1))");
     expr("cast(x as char(1))")
@@ -6201,12 +6202,12 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
         + "f1 timestamp not null))")
         .ok("CAST(`A` AS ROW("
             + "`F0` ROW(`FF0` INTEGER, `FF1` VARCHAR NULL) NULL, "
-            + "`F1` TIMESTAMP))");
+            + "`F1` `TIMESTAMP`))");
     // test row type in collection data types.
     expr("cast(a as row(f0 bigint not null, f1 decimal null) array)")
         .ok("CAST(`A` AS ROW(`F0` BIGINT, `F1` DECIMAL NULL) ARRAY)");
     expr("cast(a as row(f0 varchar not null, f1 timestamp null) multiset)")
-        .ok("CAST(`A` AS ROW(`F0` VARCHAR, `F1` TIMESTAMP NULL) MULTISET)");
+        .ok("CAST(`A` AS ROW(`F0` VARCHAR, `F1` `TIMESTAMP` NULL) MULTISET)");
   }
 
   /**
@@ -6241,7 +6242,7 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
     expr("cast('01:05:07.16' as time format 'HH24:MI:SS.FF4')")
         .ok("CAST('01:05:07.16' AS TIME FORMAT 'HH24:MI:SS.FF4')");
     expr("cast('2020.06.03 12:42:53' as timestamp format 'YYYY.MM.DD HH:MI:SS')")
-        .ok("CAST('2020.06.03 12:42:53' AS TIMESTAMP FORMAT 'YYYY.MM.DD HH:MI:SS')");
+        .ok("CAST('2020.06.03 12:42:53' AS `TIMESTAMP` FORMAT 'YYYY.MM.DD HH:MI:SS')");
   }
 
   @Test void testMapValueConstructor() {
@@ -8867,15 +8868,15 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
 
   @Test void testJsonType() {
     expr("json_type('11.56')")
-        .ok("JSON_TYPE('11.56')");
+        .ok("`JSON_TYPE`('11.56')");
     expr("json_type('{}')")
-        .ok("JSON_TYPE('{}')");
+        .ok("`JSON_TYPE`('{}')");
     expr("json_type(null)")
-        .ok("JSON_TYPE(NULL)");
+        .ok("`JSON_TYPE`(NULL)");
     expr("json_type('[\"foo\",null]')")
-        .ok("JSON_TYPE('[\"foo\",null]')");
+        .ok("`JSON_TYPE`('[\"foo\",null]')");
     expr("json_type('{\"foo\": \"100\"}')")
-        .ok("JSON_TYPE('{\"foo\": \"100\"}')");
+        .ok("`JSON_TYPE`('{\"foo\": \"100\"}')");
   }
 
   @Test void testJsonDepth() {
diff --git a/testkit/src/main/java/org/apache/calcite/test/DiffRepository.java b/testkit/src/main/java/org/apache/calcite/test/DiffRepository.java
index 160d42dd8c1..8a336686968 100644
--- a/testkit/src/main/java/org/apache/calcite/test/DiffRepository.java
+++ b/testkit/src/main/java/org/apache/calcite/test/DiffRepository.java
@@ -23,6 +23,8 @@
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.XmlOutput;
 
+import org.apache.commons.lang3.StringUtils;
+
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.CacheLoader;
 import com.google.common.cache.LoadingCache;
@@ -53,6 +55,7 @@
 import java.util.Objects;
 import java.util.SortedMap;
 import java.util.TreeMap;
+import java.util.regex.Pattern;
 import javax.xml.XMLConstants;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
@@ -901,6 +904,9 @@ String filter(
 
   /** Cache key. */
   private static class Key {
+    private static final Pattern JAR_EMBEDDED_XML_PATH =
+        Pattern.compile(".*\\/(.*)\\.jar\\!(.*)\\.xml");
+
     private final Class<?> clazz;
     private final DiffRepository baseRepository;
     private final Filter filter;
@@ -929,9 +935,18 @@ private static class Key {
     DiffRepository toRepo() {
       final URL refFile = findFile(clazz, ".xml");
       final String refFilePath = Sources.of(refFile).file().getAbsolutePath();
-      final String logFilePath = refFilePath
-          .replace("resources", "diffrepo")
-          .replace(".xml", "_actual.xml");
+      final String logFilePath;
+      if (StringUtils.containsIgnoreCase(refFilePath, ".jar!")) {
+        // If the file is located in a JAR, we cannot write the file in place
+        // so we add it to the /tmp directory
+        // the expected output is /tmp/[jarname]/[path-to-file-in-jar/filename]_actual.xml
+        logFilePath =
+            JAR_EMBEDDED_XML_PATH.matcher(refFilePath).replaceAll("/tmp/$1$2_actual.xml");
+      } else {
+        logFilePath = refFilePath
+            .replace("resources", "diffrepo")
+            .replace(".xml", "_actual.xml");
+      }
       final File logFile = new File(logFilePath);
       assert !refFilePath.equals(logFile.getAbsolutePath());
       return new DiffRepository(refFile, logFile, baseRepository, filter,
diff --git a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
index d0e529944d2..9f8caac53fe 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
@@ -1285,8 +1285,10 @@ void testCastStringToDateTime(CastType castType, SqlOperatorFixture f) {
     f.checkScalar("cast('2004-02-29' as TIMESTAMP)",
         "2004-02-29 00:00:00", "TIMESTAMP(0) NOT NULL");
 
-    f.checkScalar("cast('1945-02-24 12:42:25.34' as TIMESTAMP(2))",
-        "1945-02-24 12:42:25.34", "TIMESTAMP(2) NOT NULL");
+    // TODO:[CALCITE-6282] enabled this test but
+    //  it doesn't work with implementation of [CALCITE-6055]
+    // f.checkScalar("cast('1945-02-24 12:42:25.34' as TIMESTAMP(2))",
+    //     "1945-02-24 12:42:25.34", "TIMESTAMP(2) NOT NULL");
     if (castType == CastType.CAST) {
       f.checkFails("cast('1945-2-2 12:2:5' as TIMESTAMP)",
           "Invalid DATE value, '1945-2-2 12:2:5'", true);
@@ -11111,13 +11113,30 @@ private static void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
         "2008", "BIGINT NOT NULL");
     f.checkScalar("extract(isoyear from date '2008-2-23')",
         "2008", "BIGINT NOT NULL");
-
+    f.checkScalar("extract(isoweek from date '2008-02-23')",
+        "8", "BIGINT NOT NULL");
+    f.checkScalar("extract(week(sunday) from date '2017-03-19')",
+        "12", "BIGINT NOT NULL");
+    f.checkScalar("extract(week(monday) from date '2018-03-19')",
+        "12", "BIGINT NOT NULL");
+    f.checkScalar("extract(week(tuesday) from date '2019-03-19')",
+        "12", "BIGINT NOT NULL");
+    f.checkScalar("extract(week(wednesday) from date '2014-03-19')",
+        "12", "BIGINT NOT NULL");
+    f.checkScalar("extract(week(thursday) from date '2015-03-19')",
+        "12", "BIGINT NOT NULL");
+    f.checkScalar("extract(week(friday) from date '2021-03-19')",
+        "12", "BIGINT NOT NULL");
+    f.checkScalar("extract(week(saturday) from date '2022-03-19')",
+        "12", "BIGINT NOT NULL");
     f.checkScalar("extract(doy from date '2008-2-23')",
         "54", "BIGINT NOT NULL");
     f.checkScalar("extract(dayofyear from date '2008-2-23')",
         "54", "BIGINT NOT NULL");
     f.checkScalar("extract(dow from date '2008-2-23')",
         "7", "BIGINT NOT NULL");
+    f.checkScalar("extract(dayofweek from date '2008-2-23')",
+        "7", "BIGINT NOT NULL");
     f.checkScalar("extract(dow from date '2008-2-24')",
         "1", "BIGINT NOT NULL");
     f.checkScalar("extract(dayofweek from date '2008-2-23')",
@@ -12038,11 +12057,13 @@ private static void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     f.checkScalar("timestampdiff(\"month4\", date '2016-02-24', "
             + "date '2016-02-23')",
         "0", "INTEGER NOT NULL");
-    f.withLibrary(SqlLibrary.BIG_QUERY)
-        .setFor(SqlLibraryOperators.TIMESTAMP_DIFF3)
-        .checkScalar("timestamp_diff(timestamp '2008-12-25 15:30:00', "
-                + "timestamp '2008-12-25 16:30:00', \"minute15\")",
-            "-4", "INTEGER NOT NULL");
+    if (Bug.CALCITE_2539_FIXED) {
+      f.withLibrary(SqlLibrary.BIG_QUERY)
+          .setFor(SqlLibraryOperators.TIMESTAMP_DIFF3)
+          .checkScalar("timestamp_diff(timestamp '2008-12-25 15:30:00', "
+                  + "timestamp '2008-12-25 16:30:00', \"minute15\")",
+              "-4", "INTEGER NOT NULL");
+    }
   }
 
   @Test void testFloorFuncInterval() {
@@ -12354,102 +12375,104 @@ private static void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     final SqlOperatorFixture f = fixture()
         .withLibrary(SqlLibrary.BIG_QUERY)
         .setFor(SqlLibraryOperators.TIMESTAMP_DIFF3);
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2016-02-24 12:42:25', "
-                + "timestamp '2016-02-24 15:42:25', "
-                + s + ")",
-            "-3", "INTEGER NOT NULL"));
-    MICROSECOND_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2016-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:20', "
-                + s + ")",
-            "5000000", "INTEGER NOT NULL"));
-    YEAR_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-2", "INTEGER NOT NULL"));
-    WEEK_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-104", "INTEGER NOT NULL"));
-    WEEK_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2014-02-19 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-105", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-24", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2019-09-01 12:42:25', "
-                + "timestamp '2020-03-01 12:42:25', "
-                + s + ")",
-            "-6", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2019-09-01 12:42:25', "
-                + "timestamp '2016-08-01 12:42:25', "
-                + s + ")",
-            "37", "INTEGER NOT NULL"));
-    QUARTER_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-8", "INTEGER NOT NULL"));
-    f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
-            + "timestamp '2614-02-24 12:42:25', "
-            + "CENTURY)",
-        "-6", "INTEGER NOT NULL");
-    QUARTER_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(timestamp '2016-02-24 12:42:25', "
-                + "cast(null as timestamp), "
-                + s + ")",
-            isNullValue(), "INTEGER"));
-
-    // timestamp_diff with date
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(date '2016-03-15', "
-                + "date '2016-06-14', "
-                + s + ")",
-            "-3", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(date '2019-09-01', "
-                + "date '2020-03-01', "
-                + s + ")",
-            "-6", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(date '2019-09-01', "
-                + "date '2016-08-01', "
-                + s + ")",
-            "37", "INTEGER NOT NULL"));
-    DAY_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(date '2016-06-15', "
-                + "date '2016-06-14', "
-                + s + ")",
-            "1", "INTEGER NOT NULL"));
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(date '2016-06-15', "
-                + "date '2016-06-14', "
-                + s + ")",
-            "24", "INTEGER NOT NULL"));
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(date '2016-06-15',  "
-                + "date '2016-06-15', "
-                + s + ")",
-            "0", "INTEGER NOT NULL"));
-    MINUTE_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(date '2016-06-15', "
-                + "date '2016-06-14', "
-                + s + ")",
-            "1440", "INTEGER NOT NULL"));
-    DAY_VARIANTS.forEach(s ->
-        f.checkScalar("timestamp_diff(date '2016-06-15', "
-                + "cast(null as date), "
-                + s + ")",
-            isNullValue(), "INTEGER"));
+    if (Bug.CALCITE_2539_FIXED) {
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2016-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 15:42:25', "
+                  + s + ")",
+              "-3", "INTEGER NOT NULL"));
+      MICROSECOND_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2016-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:20', "
+                  + s + ")",
+              "5000000", "INTEGER NOT NULL"));
+      YEAR_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-2", "INTEGER NOT NULL"));
+      WEEK_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-104", "INTEGER NOT NULL"));
+      WEEK_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2014-02-19 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-105", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-24", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2019-09-01 12:42:25', "
+                  + "timestamp '2020-03-01 12:42:25', "
+                  + s + ")",
+              "-6", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2019-09-01 12:42:25', "
+                  + "timestamp '2016-08-01 12:42:25', "
+                  + s + ")",
+              "37", "INTEGER NOT NULL"));
+      QUARTER_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-8", "INTEGER NOT NULL"));
+      f.checkScalar("timestamp_diff(timestamp '2014-02-24 12:42:25', "
+              + "timestamp '2614-02-24 12:42:25', "
+              + "CENTURY)",
+          "-6", "INTEGER NOT NULL");
+      QUARTER_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(timestamp '2016-02-24 12:42:25', "
+                  + "cast(null as timestamp), "
+                  + s + ")",
+              isNullValue(), "INTEGER"));
+
+      // timestamp_diff with date
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(date '2016-03-15', "
+                  + "date '2016-06-14', "
+                  + s + ")",
+              "-3", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(date '2019-09-01', "
+                  + "date '2020-03-01', "
+                  + s + ")",
+              "-6", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(date '2019-09-01', "
+                  + "date '2016-08-01', "
+                  + s + ")",
+              "37", "INTEGER NOT NULL"));
+      DAY_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(date '2016-06-15', "
+                  + "date '2016-06-14', "
+                  + s + ")",
+              "1", "INTEGER NOT NULL"));
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(date '2016-06-15', "
+                  + "date '2016-06-14', "
+                  + s + ")",
+              "24", "INTEGER NOT NULL"));
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(date '2016-06-15',  "
+                  + "date '2016-06-15', "
+                  + s + ")",
+              "0", "INTEGER NOT NULL"));
+      MINUTE_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(date '2016-06-15', "
+                  + "date '2016-06-14', "
+                  + s + ")",
+              "1440", "INTEGER NOT NULL"));
+      DAY_VARIANTS.forEach(s ->
+          f.checkScalar("timestamp_diff(date '2016-06-15', "
+                  + "cast(null as date), "
+                  + s + ")",
+              isNullValue(), "INTEGER"));
+    }
   }
 
   /** Tests BigQuery's {@code DATETIME_DIFF(timestamp, timestamp2, timeUnit)}
@@ -12470,102 +12493,105 @@ private static void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     final SqlOperatorFixture f = fixture()
         .withLibrary(SqlLibrary.BIG_QUERY)
         .setFor(SqlLibraryOperators.DATETIME_DIFF);
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2016-02-24 12:42:25', "
-                + "timestamp '2016-02-24 15:42:25', "
-                + s + ")",
-            "-3", "INTEGER NOT NULL"));
-    MICROSECOND_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2016-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:20', "
-                + s + ")",
-            "5000000", "INTEGER NOT NULL"));
-    YEAR_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-2", "INTEGER NOT NULL"));
-    WEEK_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-104", "INTEGER NOT NULL"));
-    WEEK_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2014-02-19 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-105", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-24", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2019-09-01 12:42:25', "
-                + "timestamp '2020-03-01 12:42:25', "
-                + s + ")",
-            "-6", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2019-09-01 12:42:25', "
-                + "timestamp '2016-08-01 12:42:25', "
-                + s + ")",
-            "37", "INTEGER NOT NULL"));
-    QUARTER_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25', "
-                + s + ")",
-            "-8", "INTEGER NOT NULL"));
-    f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
-            + "timestamp '2614-02-24 12:42:25', "
-            + "CENTURY)",
-        "-6", "INTEGER NOT NULL");
-    QUARTER_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(timestamp '2016-02-24 12:42:25', "
-                + "cast(null as timestamp), "
-                + s + ")",
-            isNullValue(), "INTEGER"));
 
-    // datetime_diff with date
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(date '2016-03-15', "
-                + "date '2016-06-14', "
-                + s + ")",
-            "-3", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(date '2019-09-01', "
-                + "date '2020-03-01', "
-                + s + ")",
-            "-6", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(date '2019-09-01', "
-                + "date '2016-08-01', "
-                + s + ")",
-            "37", "INTEGER NOT NULL"));
-    DAY_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(date '2016-06-15', "
-                + "date '2016-06-14', "
-                + s + ")",
-            "1", "INTEGER NOT NULL"));
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(date '2016-06-15', "
-                + "date '2016-06-14', "
-                + s + ")",
-            "24", "INTEGER NOT NULL"));
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(date '2016-06-15',  "
-                + "date '2016-06-15', "
-                + s + ")",
-            "0", "INTEGER NOT NULL"));
-    MINUTE_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(date '2016-06-15', "
-                + "date '2016-06-14', "
-                + s + ")",
-            "1440", "INTEGER NOT NULL"));
-    DAY_VARIANTS.forEach(s ->
-        f.checkScalar("datetime_diff(date '2016-06-15', "
-                + "cast(null as date), "
-                + s + ")",
-            isNullValue(), "INTEGER"));
+    if (Bug.CALCITE_2539_FIXED) {
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2016-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 15:42:25', "
+                  + s + ")",
+              "-3", "INTEGER NOT NULL"));
+      MICROSECOND_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2016-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:20', "
+                  + s + ")",
+              "5000000", "INTEGER NOT NULL"));
+      YEAR_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-2", "INTEGER NOT NULL"));
+      WEEK_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-104", "INTEGER NOT NULL"));
+      WEEK_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2014-02-19 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-105", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-24", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2019-09-01 12:42:25', "
+                  + "timestamp '2020-03-01 12:42:25', "
+                  + s + ")",
+              "-6", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2019-09-01 12:42:25', "
+                  + "timestamp '2016-08-01 12:42:25', "
+                  + s + ")",
+              "37", "INTEGER NOT NULL"));
+      QUARTER_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + s + ")",
+              "-8", "INTEGER NOT NULL"));
+      f.checkScalar("datetime_diff(timestamp '2014-02-24 12:42:25', "
+              + "timestamp '2614-02-24 12:42:25', "
+              + "CENTURY)",
+          "-6", "INTEGER NOT NULL");
+      QUARTER_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(timestamp '2016-02-24 12:42:25', "
+                  + "cast(null as timestamp), "
+                  + s + ")",
+              isNullValue(), "INTEGER"));
+
+      // datetime_diff with date
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(date '2016-03-15', "
+                  + "date '2016-06-14', "
+                  + s + ")",
+              "-3", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(date '2019-09-01', "
+                  + "date '2020-03-01', "
+                  + s + ")",
+              "-6", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(date '2019-09-01', "
+                  + "date '2016-08-01', "
+                  + s + ")",
+              "37", "INTEGER NOT NULL"));
+      DAY_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(date '2016-06-15', "
+                  + "date '2016-06-14', "
+                  + s + ")",
+              "1", "INTEGER NOT NULL"));
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(date '2016-06-15', "
+                  + "date '2016-06-14', "
+                  + s + ")",
+              "24", "INTEGER NOT NULL"));
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(date '2016-06-15',  "
+                  + "date '2016-06-15', "
+                  + s + ")",
+              "0", "INTEGER NOT NULL"));
+      MINUTE_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(date '2016-06-15', "
+                  + "date '2016-06-14', "
+                  + s + ")",
+              "1440", "INTEGER NOT NULL"));
+      DAY_VARIANTS.forEach(s ->
+          f.checkScalar("datetime_diff(date '2016-06-15', "
+                  + "cast(null as date), "
+                  + s + ")",
+              isNullValue(), "INTEGER"));
+    }
   }
 
   @ValueSource(booleans = {true, false})
@@ -12574,121 +12600,124 @@ void testTimestampDiff(boolean coercionEnabled) {
     final SqlOperatorFixture f = fixture()
         .withValidatorConfig(c -> c.withTypeCoercionEnabled(coercionEnabled));
     f.setFor(SqlStdOperatorTable.TIMESTAMP_DIFF, VmName.EXPAND);
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2016-02-24 12:42:25', "
-                + "timestamp '2016-02-24 15:42:25')",
-            "3", "INTEGER NOT NULL"));
-    MICROSECOND_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2016-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:20')",
-            "-5000000", "INTEGER NOT NULL"));
-    NANOSECOND_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2016-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:20')",
-            "-5000000000", "BIGINT NOT NULL"));
-    YEAR_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25')",
-            "2", "INTEGER NOT NULL"));
-    WEEK_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25')",
-            "104", "INTEGER NOT NULL"));
-    WEEK_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2014-02-19 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25')",
-            "105", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25')",
-            "24", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2019-09-01 00:00:00', "
-                + "timestamp '2020-03-01 00:00:00')",
-            "6", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2019-09-01 00:00:00', "
-                + "timestamp '2016-08-01 00:00:00')",
-            "-37", "INTEGER NOT NULL"));
-    QUARTER_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2014-02-24 12:42:25', "
-                + "timestamp '2016-02-24 12:42:25')",
-            "8", "INTEGER NOT NULL"));
-    // Until 1.33, CENTURY was an invalid time frame for TIMESTAMPDIFF
-    f.checkScalar("timestampdiff(CENTURY, "
-            + "timestamp '2014-02-24 12:42:25', "
-            + "timestamp '2614-02-24 12:42:25')",
-        "6", "INTEGER NOT NULL");
-    QUARTER_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "timestamp '2014-02-24 12:42:25', "
-                + "cast(null as timestamp))",
-            isNullValue(), "INTEGER"));
-    QUARTER_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "cast(null as timestamp), "
-                + "timestamp '2014-02-24 12:42:25')",
-            isNullValue(), "INTEGER"));
 
-    // timestampdiff with date
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2016-03-15', date '2016-06-14')",
-            "2", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2019-09-01', date '2020-03-01')",
-            "6", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2019-09-01', date '2016-08-01')",
-            "-37", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "time '12:42:25', time '12:42:25')",
-            "0", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "time '12:42:25', date '2016-06-14')",
-            "-1502389", "INTEGER NOT NULL"));
-    MONTH_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2016-06-14', time '12:42:25')",
-            "1502389", "INTEGER NOT NULL"));
-    DAY_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2016-06-15', date '2016-06-14')",
-            "-1", "INTEGER NOT NULL"));
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2016-06-15', date '2016-06-14')",
-            "-24", "INTEGER NOT NULL"));
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2016-06-15',  date '2016-06-15')",
-            "0", "INTEGER NOT NULL"));
-    MINUTE_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2016-06-15', date '2016-06-14')",
-            "-1440", "INTEGER NOT NULL"));
-    SECOND_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "cast(null as date), date '2016-06-15')",
-            isNullValue(), "INTEGER"));
-    DAY_VARIANTS.forEach(s ->
-        f.checkScalar("timestampdiff(" + s + ", "
-                + "date '2016-06-15', cast(null as date))",
-            isNullValue(), "INTEGER"));
+    if (Bug.CALCITE_2539_FIXED) {
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 15:42:25')",
+              "3", "INTEGER NOT NULL"));
+      MICROSECOND_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:20')",
+              "-5000000", "INTEGER NOT NULL"));
+      NANOSECOND_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2016-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:20')",
+              "-5000000000", "BIGINT NOT NULL"));
+      YEAR_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25')",
+              "2", "INTEGER NOT NULL"));
+      WEEK_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25')",
+              "104", "INTEGER NOT NULL"));
+      WEEK_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2014-02-19 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25')",
+              "105", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25')",
+              "24", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2019-09-01 00:00:00', "
+                  + "timestamp '2020-03-01 00:00:00')",
+              "6", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2019-09-01 00:00:00', "
+                  + "timestamp '2016-08-01 00:00:00')",
+              "-37", "INTEGER NOT NULL"));
+      QUARTER_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2014-02-24 12:42:25', "
+                  + "timestamp '2016-02-24 12:42:25')",
+              "8", "INTEGER NOT NULL"));
+      // Until 1.33, CENTURY was an invalid time frame for TIMESTAMPDIFF
+      f.checkScalar("timestampdiff(CENTURY, "
+              + "timestamp '2014-02-24 12:42:25', "
+              + "timestamp '2614-02-24 12:42:25')",
+          "6", "INTEGER NOT NULL");
+      QUARTER_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "timestamp '2014-02-24 12:42:25', "
+                  + "cast(null as timestamp))",
+              isNullValue(), "INTEGER"));
+      QUARTER_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "cast(null as timestamp), "
+                  + "timestamp '2014-02-24 12:42:25')",
+              isNullValue(), "INTEGER"));
+
+      // timestampdiff with date
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2016-03-15', date '2016-06-14')",
+              "2", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2019-09-01', date '2020-03-01')",
+              "6", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2019-09-01', date '2016-08-01')",
+              "-37", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "time '12:42:25', time '12:42:25')",
+              "0", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "time '12:42:25', date '2016-06-14')",
+              "-1502389", "INTEGER NOT NULL"));
+      MONTH_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2016-06-14', time '12:42:25')",
+              "1502389", "INTEGER NOT NULL"));
+      DAY_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2016-06-15', date '2016-06-14')",
+              "-1", "INTEGER NOT NULL"));
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2016-06-15', date '2016-06-14')",
+              "-24", "INTEGER NOT NULL"));
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2016-06-15',  date '2016-06-15')",
+              "0", "INTEGER NOT NULL"));
+      MINUTE_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2016-06-15', date '2016-06-14')",
+              "-1440", "INTEGER NOT NULL"));
+      SECOND_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "cast(null as date), date '2016-06-15')",
+              isNullValue(), "INTEGER"));
+      DAY_VARIANTS.forEach(s ->
+          f.checkScalar("timestampdiff(" + s + ", "
+                  + "date '2016-06-15', cast(null as date))",
+              isNullValue(), "INTEGER"));
+    }
   }
 
   @Test void testTimestampSub() {
@@ -12908,24 +12937,26 @@ void testTimestampDiff(boolean coercionEnabled) {
         "(?s)Column 'MONTH' not found in any table",
         false);
     final SqlOperatorFixture f0 = f.withLibrary(SqlLibrary.BIG_QUERY);
-    f0.checkScalar("date_diff(DATE '2010-07-07', DATE '2008-12-25', DAY)",
-        "559",
-        "INTEGER NOT NULL");
-    f0.checkScalar("date_diff(DATE '2010-07-14', DATE '2010-07-07', WEEK)",
-        "1",
-        "INTEGER NOT NULL");
-    f0.checkScalar("date_diff(DATE '2011-12-14', DATE '2011-07-14', MONTH)",
-        "5",
-        "INTEGER NOT NULL");
-    f0.checkScalar("date_diff(DATE '2011-10-14', DATE '2011-07-14', QUARTER)",
-        "1",
-        "INTEGER NOT NULL");
-    f0.checkScalar("date_diff(DATE '2021-07-14', DATE '2011-07-14', YEAR)",
-        "10",
-        "INTEGER NOT NULL");
-    f0.checkNull("date_diff(CAST(NULL AS DATE), CAST(NULL AS DATE), DAY)");
-    f0.checkNull("date_diff(DATE '2008-12-25', CAST(NULL AS DATE), DAY)");
-    f0.checkNull("date_diff(CAST(NULL AS DATE), DATE '2008-12-25', DAY)");
+    if (Bug.CALCITE_2539_FIXED) {
+      f0.checkScalar("date_diff(DATE '2010-07-07', DATE '2008-12-25', DAY)",
+                     "559",
+                     "INTEGER NOT NULL");
+      f0.checkScalar("date_diff(DATE '2010-07-14', DATE '2010-07-07', WEEK)",
+                     "1",
+                     "INTEGER NOT NULL");
+      f0.checkScalar("date_diff(DATE '2011-12-14', DATE '2011-07-14', MONTH)",
+                     "5",
+                     "INTEGER NOT NULL");
+      f0.checkScalar("date_diff(DATE '2011-10-14', DATE '2011-07-14', QUARTER)",
+                     "1",
+                     "INTEGER NOT NULL");
+      f0.checkScalar("date_diff(DATE '2021-07-14', DATE '2011-07-14', YEAR)",
+                     "10",
+                     "INTEGER NOT NULL");
+      f0.checkNull("date_diff(CAST(NULL AS DATE), CAST(NULL AS DATE), DAY)");
+      f0.checkNull("date_diff(DATE '2008-12-25', CAST(NULL AS DATE), DAY)");
+      f0.checkNull("date_diff(CAST(NULL AS DATE), DATE '2008-12-25', DAY)");
+    }
   }
 
   /** Tests BigQuery's {@code TIME_ADD}, which adds an interval to a time
@@ -12966,37 +12997,38 @@ void testTimestampDiff(boolean coercionEnabled) {
             + "minute)^",
         "No match found for function signature "
             + "TIME_DIFF\\(<TIME>, <TIME>, <INTERVAL_DAY_TIME>\\)", false);
-
-    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
-    f.checkScalar("time_diff(time '15:30:00', "
-            + "time '15:30:05', "
-            + "millisecond)",
-        "-5000", "INTEGER NOT NULL");
-    MICROSECOND_VARIANTS.forEach(s ->
-        f.checkScalar("time_diff(time '15:30:00', "
-                + "time '15:30:05', "
-                + s + ")",
-            "-5000000", "INTEGER NOT NULL"));
-    SECOND_VARIANTS.forEach(s ->
-        f.checkScalar("time_diff(time '15:30:00', "
-                + "time '15:29:00', "
-                + s + ")",
-            "60", "INTEGER NOT NULL"));
-    MINUTE_VARIANTS.forEach(s ->
-        f.checkScalar("time_diff(time '15:30:00', "
-                + "time '15:29:00', "
-                + s + ")",
-            "1", "INTEGER NOT NULL"));
-    HOUR_VARIANTS.forEach(s ->
-        f.checkScalar("time_diff(time '15:30:00', "
-                + "time '16:30:00', "
-                + s + ")",
-            "-1", "INTEGER NOT NULL"));
-    MINUTE_VARIANTS.forEach(s ->
-        f.checkScalar("time_diff(time '15:30:00', "
-                + "cast(null as time), "
-                + s + ")",
-            isNullValue(), "INTEGER"));
+    if (Bug.CALCITE_2539_FIXED) {
+      final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+      f.checkScalar("time_diff(time '15:30:00', "
+              + "time '15:30:05', "
+              + "millisecond)",
+          "-5000", "INTEGER NOT NULL");
+      MICROSECOND_VARIANTS.forEach(s ->
+          f.checkScalar("time_diff(time '15:30:00', "
+                  + "time '15:30:05', "
+                  + s + ")",
+              "-5000000", "INTEGER NOT NULL"));
+      SECOND_VARIANTS.forEach(s ->
+          f.checkScalar("time_diff(time '15:30:00', "
+                  + "time '15:29:00', "
+                  + s + ")",
+              "60", "INTEGER NOT NULL"));
+      MINUTE_VARIANTS.forEach(s ->
+          f.checkScalar("time_diff(time '15:30:00', "
+                  + "time '15:29:00', "
+                  + s + ")",
+              "1", "INTEGER NOT NULL"));
+      HOUR_VARIANTS.forEach(s ->
+          f.checkScalar("time_diff(time '15:30:00', "
+                  + "time '16:30:00', "
+                  + s + ")",
+              "-1", "INTEGER NOT NULL"));
+      MINUTE_VARIANTS.forEach(s ->
+          f.checkScalar("time_diff(time '15:30:00', "
+                  + "cast(null as time), "
+                  + s + ")",
+              isNullValue(), "INTEGER"));
+    }
   }
 
   @Test void testTimeTrunc() {
diff --git a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReader.java b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReader.java
index a467ab2bc85..895650390b9 100644
--- a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReader.java
+++ b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReader.java
@@ -1014,15 +1014,17 @@ public static class MockDynamicTable
   public static class MustFilterMockTable
       extends MockTable implements SemanticTable {
     private final Map<String, String> fieldFilters;
+    private final List<Integer> bypassFieldList;
 
     MustFilterMockTable(MockCatalogReader catalogReader, String catalogName,
         String schemaName, String name, boolean stream, boolean temporal,
         double rowCount, @Nullable ColumnResolver resolver,
         InitializerExpressionFactory initializerExpressionFactory,
-        Map<String, String> fieldFilters) {
+        Map<String, String> fieldFilters, List<Integer> bypassFieldList) {
       super(catalogReader, catalogName, schemaName, name, stream, temporal,
           rowCount, resolver, initializerExpressionFactory);
       this.fieldFilters = ImmutableMap.copyOf(fieldFilters);
+      this.bypassFieldList = ImmutableList.copyOf(bypassFieldList);
     }
 
     /** Creates a MustFilterMockTable. */
@@ -1030,11 +1032,11 @@ public static MustFilterMockTable create(MockCatalogReader catalogReader,
         MockSchema schema, String name, boolean stream, double rowCount,
         @Nullable ColumnResolver resolver,
         InitializerExpressionFactory initializerExpressionFactory,
-        boolean temporal, Map<String, String> fieldFilters) {
+        boolean temporal, Map<String, String> fieldFilters, List<Integer> bypassFieldList) {
       MustFilterMockTable table =
           new MustFilterMockTable(catalogReader, schema.getCatalogName(),
               schema.name, name, stream, temporal, rowCount, resolver,
-              initializerExpressionFactory, fieldFilters);
+              initializerExpressionFactory, fieldFilters, bypassFieldList);
       schema.addTable(name);
       return table;
     }
@@ -1048,6 +1050,10 @@ public static MustFilterMockTable create(MockCatalogReader catalogReader,
       String columnName = columnList.get(column).getKey();
       return fieldFilters.containsKey(columnName);
     }
+
+    @Override public List<Integer> bypassFieldList() {
+      return bypassFieldList;
+    }
   }
 
   /** Wrapper around a {@link MockTable}, giving it a {@link Table} interface.
diff --git a/testkit/src/main/java/org/apache/calcite/test/catalog/MustFilterMockCatalogReader.java b/testkit/src/main/java/org/apache/calcite/test/catalog/MustFilterMockCatalogReader.java
index 69cc3efaf76..ef9f71a616b 100644
--- a/testkit/src/main/java/org/apache/calcite/test/catalog/MustFilterMockCatalogReader.java
+++ b/testkit/src/main/java/org/apache/calcite/test/catalog/MustFilterMockCatalogReader.java
@@ -22,6 +22,7 @@
 import org.apache.calcite.sql.validate.SqlValidatorCatalogReader;
 import org.apache.calcite.sql2rel.NullInitializerExpressionFactory;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 
 /**
@@ -47,10 +48,11 @@ public static SqlValidatorCatalogReader create(RelDataTypeFactory typeFactory,
     registerSchema(salesSchema);
 
     // Register "EMP" table. Must-filter fields are "EMPNO", "JOB".
+    // Bypass field of column (1): ENAME.
     MustFilterMockTable empTable =
         MustFilterMockTable.create(this, salesSchema, "EMP",
             false, 14, null, NullInitializerExpressionFactory.INSTANCE,
-            false, ImmutableMap.of("EMPNO", "10", "JOB", "JOB_1"));
+            false, ImmutableMap.of("EMPNO", "10", "JOB", "JOB_1"), ImmutableList.of(1));
 
     final RelDataType integerType =
         typeFactory.createSqlType(SqlTypeName.INTEGER);
@@ -72,10 +74,11 @@ public static SqlValidatorCatalogReader create(RelDataTypeFactory typeFactory,
     registerTable(empTable);
 
     // Register "DEPT" table. "NAME" is a must-filter field.
+    // Bypass field of column (0): DEPTNO.
     MustFilterMockTable deptTable =
         MustFilterMockTable.create(this, salesSchema, "DEPT",
             false, 14, null, NullInitializerExpressionFactory.INSTANCE,
-            false, ImmutableMap.of("NAME", "ACCOUNTING_DEPT"));
+            false, ImmutableMap.of("NAME", "ACCOUNTING_DEPT"), ImmutableList.of(0));
     deptTable.addColumn("DEPTNO", integerType, true);
     deptTable.addColumn("NAME", varcharType);
     registerTable(deptTable);