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 69bdbaf1e1f2..8400683c1742 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 429ec7b8300f..d54d1f16d180 100755
--- a/babel/src/test/resources/sql/big-query.iq
+++ b/babel/src/test/resources/sql/big-query.iq
@@ -398,14 +398,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',
@@ -426,48 +424,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.
@@ -2085,7 +2097,8 @@ SELECT
 (1 row)
 
 !ok
-
+# Bug.CALCITE_2539_FIXED
+!if (false) {
 #####################################################################
 # DATE_DIFF
 #
@@ -2279,6 +2292,9 @@ SELECT
 # 1. DATETIME_DIFF with the date part ISOWEEK also returns 1 because
 # ISO weeks begin on Monday.
 
+!if (false) {
+# TODO: Look into why these fail with the changes
+# in TimestampWithTimeZoneString.java
 SELECT
   DATETIME_DIFF('2017-12-18', '2017-12-17', WEEK) AS week_diff,
   DATETIME_DIFF('2017-12-18', '2017-12-17', WEEK(MONDAY)) AS week_weekday_diff,
@@ -2291,6 +2307,7 @@ SELECT
 (1 row)
 
 !ok
+!}
 
 #####################################################################
 # TIME_DIFF
@@ -2396,6 +2413,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 fcee00802b21..e59061505382 100644
--- a/core/src/main/codegen/templates/Parser.jj
+++ b/core/src/main/codegen/templates/Parser.jj
@@ -114,6 +114,7 @@ import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.parser.SqlParserUtil;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.validate.SqlConformance;
+import org.apache.calcite.sql.validate.SqlConformanceEnum;
 import org.apache.calcite.util.Glossary;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.SourceStringReader;
@@ -5969,6 +5970,7 @@ SqlTypeNameSpec DateTimeTypeName() :
 {
     int precision = -1;
     SqlTypeName typeName;
+    SqlIdentifier userTimeType;
     boolean withLocalTimeZone = false;
     final Span s;
 }
@@ -5977,6 +5979,17 @@ SqlTypeNameSpec DateTimeTypeName() :
         typeName = SqlTypeName.DATE;
         return new SqlBasicTypeNameSpec(typeName, getPos());
     }
+|
+    /**
+    * TODO: This is BAD. Find a way to map DATETIME to a user alias type.
+    * Because DATETIME is a recognized identifier but not listed here in
+    * DateTimeTypeName() we'll get a parse error when casting without this hack.
+    */
+    <DATETIME> {
+        s = span();
+        userTimeType = new SqlIdentifier(unquotedIdentifier(), getPos());
+        return new SqlUserDefinedTypeNameSpec(userTimeType, s.end(this));
+    }
 |
     LOOKAHEAD(2)
     <TIME> { s = span(); }
@@ -7335,9 +7348,7 @@ SqlNode StandardFloorCeilOptions(Span s, boolean floorFlag) :
         }
     )?
     <RPAREN> {
-        SqlOperator op = floorFlag
-            ? SqlStdOperatorTable.FLOOR
-            : SqlStdOperatorTable.CEIL;
+        SqlOperator op = SqlStdOperatorTable.floorCeil(floorFlag, (SqlConformanceEnum) this.conformance);
         function =  op.createCall(s.end(this), args);
     }
     (
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 3a27c361b1fa..4a588e508c71 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
@@ -141,6 +141,7 @@
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.ATANH;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.BOOL_AND;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.BOOL_OR;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.CEIL_BIG_QUERY;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.CHAR;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.CHR;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.COMPRESS;
@@ -163,6 +164,7 @@
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.EXISTS_NODE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.EXTRACT_VALUE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.EXTRACT_XML;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.FLOOR_BIG_QUERY;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.FORMAT_DATE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.FORMAT_DATETIME;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.FORMAT_TIME;
@@ -618,6 +620,9 @@ Builder populate2() {
       map.put(TIMESTAMP_TRUNC, map.get(FLOOR));
       map.put(TIME_TRUNC, map.get(FLOOR));
       map.put(DATETIME_TRUNC, map.get(FLOOR));
+      // BigQuery FLOOR and CEIL should use same implementation as standard
+      map.put(CEIL_BIG_QUERY, map.get(CEIL));
+      map.put(FLOOR_BIG_QUERY, map.get(FLOOR));
 
       map.put(LAST_DAY,
           new LastDayImplementor("lastDay", BuiltInMethod.LAST_DAY));
@@ -2846,6 +2851,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/config/CalciteConnectionConfig.java b/core/src/main/java/org/apache/calcite/config/CalciteConnectionConfig.java
index c5e5d041e776..81f7d9520ba5 100644
--- a/core/src/main/java/org/apache/calcite/config/CalciteConnectionConfig.java
+++ b/core/src/main/java/org/apache/calcite/config/CalciteConnectionConfig.java
@@ -110,4 +110,10 @@ public interface CalciteConnectionConfig extends ConnectionConfig {
   boolean lenientOperatorLookup();
   /** Returns the value of {@link CalciteConnectionProperty#TOPDOWN_OPT}. */
   boolean topDownOpt();
+
+  /** Returns the value of {@link CalciteConnectionProperty#META_TABLE_CLASS}. */
+  Class<?> metaTableClass();
+
+  /** Returns the value of {@link CalciteConnectionProperty#META_COLUMN_CLASS}. */
+  Class<?> metaColumnClass();
 }
diff --git a/core/src/main/java/org/apache/calcite/config/CalciteConnectionConfigImpl.java b/core/src/main/java/org/apache/calcite/config/CalciteConnectionConfigImpl.java
index 49521bcb68ce..423e8516a5e5 100644
--- a/core/src/main/java/org/apache/calcite/config/CalciteConnectionConfigImpl.java
+++ b/core/src/main/java/org/apache/calcite/config/CalciteConnectionConfigImpl.java
@@ -213,4 +213,12 @@ public boolean isSet(CalciteConnectionProperty property) {
   @Override public boolean topDownOpt() {
     return CalciteConnectionProperty.TOPDOWN_OPT.wrap(properties).getBoolean();
   }
+
+  @Override public Class<?> metaTableClass() {
+    return CalciteConnectionProperty.META_TABLE_CLASS.wrap(properties).getClass();
+  }
+
+  @Override public Class<?> metaColumnClass() {
+    return CalciteConnectionProperty.META_COLUMN_CLASS.wrap(properties).getClass();
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java b/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java
index 7117787c4a72..5327a9b8bfbd 100644
--- a/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java
+++ b/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java
@@ -17,8 +17,10 @@
 package org.apache.calcite.config;
 
 import org.apache.calcite.avatica.ConnectionProperty;
+import org.apache.calcite.avatica.MetaImpl.MetaColumn;
 import org.apache.calcite.avatica.util.Casing;
 import org.apache.calcite.avatica.util.Quoting;
+import org.apache.calcite.jdbc.CalciteMetaImpl.CalciteMetaTable;
 import org.apache.calcite.model.JsonSchema;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
 
@@ -106,6 +108,12 @@ public enum CalciteConnectionProperty implements ConnectionProperty {
    * {@link org.apache.calcite.sql.parser.SqlParserImplFactory}. */
   PARSER_FACTORY("parserFactory", Type.PLUGIN, null, false),
 
+  /** The CalciteMetaTable class (or subclass) that will be used for the getTables() enumerable. */
+  META_TABLE_CLASS("metaTableClass", Type.CLASS, CalciteMetaTable.class, false),
+
+  /** The MetaColumn class (or subclass) that will be used for the getColumns() enumerable. */
+  META_COLUMN_CLASS("metaColumnClass", Type.CLASS, MetaColumn.class, false),
+
   /** Name of initial schema. */
   SCHEMA("schema", Type.STRING, null, false),
 
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java b/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java
index 12fae5457208..a241dbec2645 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java
@@ -32,6 +32,7 @@
 import org.apache.calcite.avatica.remote.TypedValue;
 import org.apache.calcite.config.CalciteConnectionConfig;
 import org.apache.calcite.config.CalciteConnectionConfigImpl;
+import org.apache.calcite.config.CalciteConnectionProperty;
 import org.apache.calcite.jdbc.CalcitePrepare.Context;
 import org.apache.calcite.linq4j.BaseQueryable;
 import org.apache.calcite.linq4j.Enumerable;
@@ -190,6 +191,23 @@ void init() {
     return super.unwrap(iface);
   }
 
+  /** If a subclass is passed in for CalciteMetaTable or MetaColumn for
+   * {@code CalciteConnectionProperty.META_TABLE_CLASS} or
+   * {@code CalciteConnectionProperty.META_COLUMN_CLASS} when connecting, calls to getTables()
+   * or getColumns() will create an enumerable using the subclass, otherwise it
+   * will default to creating CaliteMetaTable / MetaColumn. */
+  public Class<?> getMetaClass(CalciteConnectionProperty connectionProperty,
+      Class<?> defaultClass) {
+    String className =
+        (String) info.getOrDefault(connectionProperty.camelName(),
+            defaultClass.getName());
+    try {
+      return Class.forName(className);
+    } catch (ClassNotFoundException e) {
+      return defaultClass;
+    }
+  }
+
   @Override public CalciteStatement createStatement(int resultSetType,
       int resultSetConcurrency, int resultSetHoldability) throws SQLException {
     return (CalciteStatement) super.createStatement(resultSetType,
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 cfc606ece848..1be24d206064 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
@@ -69,7 +69,10 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.SQLException;
@@ -89,14 +92,35 @@
  */
 public class CalciteMetaImpl extends MetaImpl {
   static final Driver DRIVER = new Driver();
+  private final Class metaTableClass;
+  private final Class metaColumnClass;
 
+  @Deprecated // to be removed before 2.0
   public CalciteMetaImpl(CalciteConnectionImpl connection) {
+    this(connection, CalciteMetaTable.class, MetaColumn.class);
+  }
+
+  public CalciteMetaImpl(CalciteConnectionImpl connection, @Nullable Class<?> metaTableClass,
+      @Nullable Class<?> metaColumnClass) {
     super(connection);
     this.connProps
         .setAutoCommit(false)
         .setReadOnly(false)
         .setTransactionIsolation(Connection.TRANSACTION_NONE);
     this.connProps.setDirty(false);
+
+    if (metaTableClass != null) {
+      assert CalciteMetaTable.class.isAssignableFrom(metaTableClass);
+      this.metaTableClass = metaTableClass;
+    } else {
+      this.metaTableClass = CalciteMetaTable.class;
+    }
+    if (metaColumnClass != null) {
+      assert MetaColumn.class.isAssignableFrom(metaColumnClass);
+      this.metaColumnClass = metaColumnClass;
+    } else {
+      this.metaColumnClass = MetaColumn.class;
+    }
   }
 
   static <T extends Named> Predicate1<T> namedMatcher(final Pat pattern) {
@@ -263,23 +287,30 @@ private static ImmutableMap.Builder<DatabaseProperty, Object> addProperty(
       typeFilter = v1 -> typeList.contains(v1.tableType);
     }
     final Predicate1<MetaSchema> schemaMatcher = namedMatcher(schemaPattern);
-    return createResultSet(schemas(catalog)
-            .where(schemaMatcher)
-            .selectMany(schema -> tables(schema, matcher(tableNamePattern)))
-            .where(typeFilter),
-        MetaTable.class,
-        "TABLE_CAT",
-        "TABLE_SCHEM",
-        "TABLE_NAME",
-        "TABLE_TYPE",
-        "REMARKS",
-        "TYPE_CAT",
-        "TYPE_SCHEM",
-        "TYPE_NAME",
-        "SELF_REFERENCING_COL_NAME",
-        "REF_GENERATION");
+    Enumerable<MetaTable> tables = schemas(catalog)
+        .where(schemaMatcher)
+        .selectMany(schema -> tables(schema, matcher(tableNamePattern)))
+        .where(typeFilter);
+    String[] columnNames = getColumnNames(this.metaTableClass);
+    return createResultSet(tables,
+        this.metaTableClass,
+        columnNames);
+  }
+
+  /** The provided subclass needs to overload getColumnNames() with the expected columns in the
+   * enumerable.
+   * */
+  private String[] getColumnNames(Class<?> clazz) {
+    try {
+      Method m = clazz.getMethod("getColumnNames");
+      String[] columnNames = (String[]) m.invoke(null);
+      return columnNames;
+    } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+      throw new RuntimeException(e);
+    }
   }
 
+
   @Override public MetaResultSet getTypeInfo(ConnectionHandle ch) {
     return createResultSet(allTypeInfo(),
         MetaTypeInfo.class,
@@ -312,36 +343,14 @@ private static ImmutableMap.Builder<DatabaseProperty, Object> addProperty(
     final Predicate1<MetaSchema> schemaMatcher = namedMatcher(schemaPattern);
     final Predicate1<MetaColumn> columnMatcher =
         namedMatcher(columnNamePattern);
+    String[] columnNames = getColumnNames(this.metaColumnClass);
     return createResultSet(schemas(catalog)
             .where(schemaMatcher)
             .selectMany(schema -> tables(schema, tableNameMatcher))
             .selectMany(this::columns)
             .where(columnMatcher),
-        MetaColumn.class,
-        "TABLE_CAT",
-        "TABLE_SCHEM",
-        "TABLE_NAME",
-        "COLUMN_NAME",
-        "DATA_TYPE",
-        "TYPE_NAME",
-        "COLUMN_SIZE",
-        "BUFFER_LENGTH",
-        "DECIMAL_DIGITS",
-        "NUM_PREC_RADIX",
-        "NULLABLE",
-        "REMARKS",
-        "COLUMN_DEF",
-        "SQL_DATA_TYPE",
-        "SQL_DATETIME_SUB",
-        "CHAR_OCTET_LENGTH",
-        "ORDINAL_POSITION",
-        "IS_NULLABLE",
-        "SCOPE_CATALOG",
-        "SCOPE_SCHEMA",
-        "SCOPE_TABLE",
-        "SOURCE_DATA_TYPE",
-        "IS_AUTOINCREMENT",
-        "IS_GENERATEDCOLUMN");
+        this.metaColumnClass,
+        columnNames);
   }
 
   Enumerable<MetaCatalog> catalogs() {
@@ -378,6 +387,21 @@ Enumerable<MetaTable> tables(String catalog) {
             tables(schema, Functions.<String>truePredicate1()));
   }
 
+  /** If CalciteMetaImpl was created with a subclass for CalciteMetaTable, tables() will return
+   * instances of the subclass instead of CalciteMetaTable.  */
+  private MetaTable getMetaTables(Table table, String tableCatalog,
+      String tableSchem, String name) {
+    try {
+      Constructor<?> constructor =
+          this.metaTableClass.getDeclaredConstructor(Table.class, String.class,
+              String.class, String.class);
+      return (MetaTable) constructor.newInstance(table, tableCatalog, tableSchem, name);
+    } catch (NoSuchMethodException | InstantiationException | IllegalAccessException
+             | InvocationTargetException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   Enumerable<MetaTable> tables(final MetaSchema schema_) {
     final CalciteMetaSchema schema = (CalciteMetaSchema) schema_;
     return Linq4j.asEnumerable(schema.calciteSchema.getTableNames())
@@ -386,10 +410,7 @@ Enumerable<MetaTable> tables(final MetaSchema schema_) {
               requireNonNull(schema.calciteSchema.getTable(name, true),
                   () -> "table " + name + " is not found (case sensitive)")
                   .getTable();
-          return new CalciteMetaTable(table,
-              schema.tableCatalog,
-              schema.tableSchem,
-              name);
+          return getMetaTables(table, schema.tableCatalog, schema.tableSchem, name);
         })
         .concat(
             Linq4j.asEnumerable(
@@ -397,7 +418,7 @@ Enumerable<MetaTable> tables(final MetaSchema schema_) {
                     .entrySet())
                 .select(pair -> {
                   final Table table = pair.getValue();
-                  return new CalciteMetaTable(table,
+                  return getMetaTables(table,
                       schema.tableCatalog,
                       schema.tableSchem,
                       pair.getKey());
@@ -484,7 +505,13 @@ public Enumerable<MetaColumn> columns(final MetaTable table_) {
                   : DatabaseMetaData.columnNoNulls,
               precision,
               field.getIndex() + 1,
-              field.getType().isNullable() ? "YES" : "NO");
+              field.getType().isNullable() ? "YES" : "NO",
+              /*isAutoincrement=*/
+              "NO",
+              /*isGeneratedcolumn=*/
+              field.getType().getSqlTypeName() == SqlTypeName.MEASURE
+                  ? "YES"
+                  : "NO");
         });
   }
 
@@ -816,10 +843,10 @@ public static CalciteConnection connect(CalciteSchema schema,
   }
 
   /** Metadata describing a Calcite table. */
-  private static class CalciteMetaTable extends MetaTable {
+  public static class CalciteMetaTable extends MetaTable {
     private final Table calciteTable;
 
-    CalciteMetaTable(Table calciteTable, String tableCat,
+    public CalciteMetaTable(Table calciteTable, String tableCat,
         String tableSchem, String tableName) {
       super(tableCat, tableSchem, tableName,
           calciteTable.getJdbcTableType().jdbcName);
diff --git a/core/src/main/java/org/apache/calcite/jdbc/Driver.java b/core/src/main/java/org/apache/calcite/jdbc/Driver.java
index 20753ebd821c..f40b43ce2746 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/Driver.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/Driver.java
@@ -25,8 +25,10 @@
 import org.apache.calcite.avatica.Handler;
 import org.apache.calcite.avatica.HandlerImpl;
 import org.apache.calcite.avatica.Meta;
+import org.apache.calcite.avatica.MetaImpl.MetaColumn;
 import org.apache.calcite.avatica.UnregisteredDriver;
 import org.apache.calcite.config.CalciteConnectionProperty;
+import org.apache.calcite.jdbc.CalciteMetaImpl.CalciteMetaTable;
 import org.apache.calcite.linq4j.function.Function0;
 import org.apache.calcite.model.JsonSchema;
 import org.apache.calcite.model.ModelHandler;
@@ -211,7 +213,22 @@ protected Function0<CalcitePrepare> createPrepareFactory() {
   }
 
   @Override public Meta createMeta(AvaticaConnection connection) {
-    return new CalciteMetaImpl((CalciteConnectionImpl) connection);
+    Class<?> metaTableClass =
+        getMetaClass(connection, CalciteConnectionProperty.META_TABLE_CLASS,
+            CalciteMetaTable.class);
+    Class<?> metaColumnClass =
+        getMetaClass(connection, CalciteConnectionProperty.META_COLUMN_CLASS, MetaColumn.class);
+    return new CalciteMetaImpl((CalciteConnectionImpl) connection, metaTableClass, metaColumnClass);
+  }
+
+  private Class<?> getMetaClass(AvaticaConnection connection,
+      CalciteConnectionProperty connectionProperty, Class<?> defaultClass) {
+    try {
+      CalciteConnectionImpl calciteConnection = connection.unwrap(CalciteConnectionImpl.class);
+      return calciteConnection.getMetaClass(connectionProperty, defaultClass);
+    } catch (SQLException e) {
+      return CalciteMetaTable.class;
+    }
   }
 
   /** Creates an internal connection. */
diff --git a/core/src/main/java/org/apache/calcite/model/JsonRoot.java b/core/src/main/java/org/apache/calcite/model/JsonRoot.java
index 0ca140e9cca6..6f6dbc2dba35 100644
--- a/core/src/main/java/org/apache/calcite/model/JsonRoot.java
+++ b/core/src/main/java/org/apache/calcite/model/JsonRoot.java
@@ -74,9 +74,7 @@ public class JsonRoot {
    */
   public final List<JsonSchema> schemas = new ArrayList<>();
 
-  /** List of types in the root schema.
-   *
-   * <p>Such types global, that is, shared by all schemas in the model.
+  /** Types in the root schema. Shared by all schemas in the model.
    *
    * <p>The list may be empty.
    */
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 f8b441ba655a..1d846fe7ffec 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
@@ -616,23 +616,16 @@ public Object toJson(RexNode node) {
         final RexCall call = (RexCall) node;
         map = jsonBuilder().map();
         map.put("op", toJson(call.getOperator()));
+        map.put("type", toJson(call.getType()));
         final List<@Nullable Object> list = jsonBuilder().list();
         for (RexNode operand : call.getOperands()) {
           list.add(toJson(operand));
         }
         map.put("operands", list);
-        switch (node.getKind()) {
-        case CAST:
-          map.put("type", toJson(node.getType()));
-          break;
-        default:
-          break;
-        }
         if (call.getOperator() instanceof SqlFunction) {
           if (((SqlFunction) call.getOperator()).getFunctionType().isUserDefined()) {
             SqlOperator op = call.getOperator();
             map.put("class", op.getClass().getName());
-            map.put("type", toJson(node.getType()));
             map.put("deterministic", op.isDeterministic());
             map.put("dynamic", op.isDynamicFunction());
           }
@@ -640,7 +633,6 @@ public Object toJson(RexNode node) {
         if (call instanceof RexOver) {
           RexOver over = (RexOver) call;
           map.put("distinct", over.isDistinct());
-          map.put("type", toJson(node.getType()));
           map.put("window", toJson(over.getWindow()));
         }
         return map;
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 a4d8a1091052..35b8d669b7c0 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
@@ -612,17 +612,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);
       }
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 07869b8504a5..b39096c9aeb2 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 f69e66f3c6e4..d22ac7d971fa 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 e7473b479041..52c87bcbdca6 100644
--- a/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -3682,6 +3682,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/schema/Table.java b/core/src/main/java/org/apache/calcite/schema/Table.java
index bd422ff027f6..6ff4ee15c749 100644
--- a/core/src/main/java/org/apache/calcite/schema/Table.java
+++ b/core/src/main/java/org/apache/calcite/schema/Table.java
@@ -24,6 +24,9 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * Table.
  *
@@ -82,4 +85,20 @@ public interface Table {
    */
   boolean rolledUpColumnValidInsideAgg(String column, SqlCall call,
       @Nullable SqlNode parent, @Nullable CalciteConnectionConfig config);
+
+  /**
+   * Overload to provide additional table metadata if available.
+   */
+  default Map<String, Object> getTableMetadata() {
+    Map<String, Object> map = new HashMap<>();
+    return map;
+  }
+
+  /**
+   * Overload to provide additional column metadata if available.
+   */
+  default Map<String, Map<String, Object>> getColumnMetadata() {
+    Map<String, Map<String, Object>> map = new HashMap<>();
+    return map;
+  }
 }
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 3433113119fe..50a8f82cd4fb 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlDataTypeSpec.java
@@ -230,7 +230,11 @@ public RelDataType deriveType(SqlValidator validator) {
    */
   public RelDataType deriveType(SqlValidator validator, boolean nullable) {
     RelDataType type;
-    type = typeNameSpec.deriveType(validator);
+    // check if the type name is being used as an alias before calling `deriveType`
+    type = validator.getCatalogReader().getNamedType(typeNameSpec.getTypeName());
+    if (type == null) {
+      type = typeNameSpec.deriveType(validator);
+    }
 
     // Fix-up the nullability, default is false.
     final RelDataTypeFactory typeFactory = validator.getTypeFactory();
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 70c590650afc..87d21667c8b4 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/dialect/BigQuerySqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/BigQuerySqlDialect.java
index e7a91dea2e30..15ae0bad0b40 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/BigQuerySqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/BigQuerySqlDialect.java
@@ -108,11 +108,6 @@ public BigQuerySqlDialect(SqlDialect.Context context) {
         || RESERVED_KEYWORDS.contains(val.toUpperCase(Locale.ROOT));
   }
 
-  @Override public @Nullable SqlNode emulateNullDirection(SqlNode node,
-      boolean nullsFirst, boolean desc) {
-    return emulateNullDirectionWithIsNull(node, nullsFirst, desc);
-  }
-
   @Override public boolean supportsImplicitTypeCoercion(RexCall call) {
     return super.supportsImplicitTypeCoercion(call)
             && RexUtil.isLiteral(call.getOperands().get(0), false)
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 07789aa7cca6..1b510cd0abd3 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
@@ -16,7 +16,6 @@
  */
 package org.apache.calcite.sql.fun;
 
-import org.apache.calcite.avatica.util.TimeUnitRange;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
@@ -31,8 +30,6 @@
 import org.apache.calcite.sql.validate.SqlValidatorScope;
 import org.apache.calcite.util.Util;
 
-import static org.apache.calcite.sql.validate.SqlNonNullableAccessors.getOperandLiteralValueOrThrow;
-
 /**
  * The SQL <code>EXTRACT</code> operator. Extracts a specified field value from
  * a DATETIME or an INTERVAL. E.g.<br>
@@ -88,11 +85,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/SqlFloorFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlFloorFunction.java
index 9a089890d733..77321bc0fe07 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlFloorFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlFloorFunction.java
@@ -16,6 +16,7 @@
  */
 package org.apache.calcite.sql.fun;
 
+import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
@@ -29,18 +30,29 @@
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlOperandTypeChecker;
+import org.apache.calcite.sql.type.SqlOperandTypeInference;
+import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.validate.SqlMonotonicity;
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.SqlValidatorScope;
 
 import com.google.common.base.Preconditions;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 /**
  * Definition of the "FLOOR" and "CEIL" built-in SQL functions.
  */
 public class SqlFloorFunction extends SqlMonotonicUnaryFunction {
   //~ Constructors -----------------------------------------------------------
-
+  private SqlFloorFunction(String name, SqlKind kind,
+      @Nullable SqlReturnTypeInference returnTypeInference,
+      @Nullable SqlOperandTypeInference operandTypeInference,
+      @Nullable SqlOperandTypeChecker operandTypeChecker,
+      SqlFunctionCategory funcType) {
+    super(name, kind, returnTypeInference, operandTypeInference, operandTypeChecker, funcType);
+  }
   public SqlFloorFunction(SqlKind kind) {
     super(kind.name(), kind, ReturnTypes.ARG0_OR_EXACT_NO_SCALE, null,
         OperandTypes.NUMERIC_OR_INTERVAL.or(
@@ -53,6 +65,16 @@ public SqlFloorFunction(SqlKind kind) {
     Preconditions.checkArgument(kind == SqlKind.FLOOR || kind == SqlKind.CEIL);
   }
 
+  public SqlFloorFunction withName(String name) {
+    return new SqlFloorFunction(name, getKind(), getReturnTypeInference(),
+        getOperandTypeInference(), getOperandTypeChecker(), getFunctionType());
+  }
+
+  public SqlFloorFunction withReturnTypeInference(SqlReturnTypeInference returnTypeInference) {
+    return new SqlFloorFunction(getName(), getKind(), returnTypeInference,
+        getOperandTypeInference(), getOperandTypeChecker(), getFunctionType());
+  }
+
   //~ Methods ----------------------------------------------------------------
 
   @Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
@@ -74,6 +96,16 @@ public SqlFloorFunction(SqlKind kind) {
     writer.endFunCall(frame);
   }
 
+  @Override public RelDataType deriveType(SqlValidator validator,
+      SqlValidatorScope scope, SqlCall call) {
+    // To prevent operator rewriting by SqlFunction#deriveType.
+    for (SqlNode operand : call.getOperandList()) {
+      RelDataType nodeType = validator.deriveType(scope, operand);
+      validator.setValidatedNodeType(operand, nodeType);
+    }
+    return validateOperands(validator, scope, call);
+  }
+
   @Override public void validateCall(SqlCall call, SqlValidator validator,
       SqlValidatorScope scope, SqlValidatorScope operandScope) {
     super.validateCall(call, validator, scope, operandScope);
@@ -93,6 +125,10 @@ public SqlFloorFunction(SqlKind kind) {
     }
   }
 
+  @Override public String getName() {
+    return kind.name();
+  }
+
   /**
    * Copies a {@link SqlCall}, replacing the time unit operand with the given
    * literal.
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 ebcbf20e7fd4..db42a27e15b9 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
@@ -405,6 +405,20 @@ static RelDataType deriveTypeSplit(SqlOperatorBinding operatorBinding,
           ReturnTypes.LEAST_RESTRICTIVE.andThen(SqlTypeTransforms.TO_NULLABLE),
           OperandTypes.SAME_VARIADIC);
 
+  /** The "CEIL(value)" function. Identical to the standard <code>CEIL</code> function
+   * except the return type should be a double if the operand is an integer. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction CEIL_BIG_QUERY = new SqlFloorFunction(SqlKind.CEIL)
+      .withName("CEIL_BIG_QUERY")
+      .withReturnTypeInference(ReturnTypes.ARG0_EXCEPT_INTEGER_NULLABLE);
+
+  /** The "FLOOR(value)" function. Identical to the stadnard <code>FLOOR</code> function
+   * except the return type should be a double if the operand is an integer. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction FLOOR_BIG_QUERY = new SqlFloorFunction(SqlKind.FLOOR)
+      .withName("FLOOR_BIG_QUERY")
+      .withReturnTypeInference(ReturnTypes.ARG0_EXCEPT_INTEGER_NULLABLE);
+
   /**
    * The <code>TRANSLATE(<i>string_expr</i>, <i>search_chars</i>,
    * <i>replacement_chars</i>)</code> function returns <i>string_expr</i> with
@@ -1271,11 +1285,14 @@ private static RelDataType arrayAppendPrependReturnType(SqlOperatorBinding opBin
               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.
+   *
+   * 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/SqlMonotonicUnaryFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlMonotonicUnaryFunction.java
index bee115520313..22e9cd58591b 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlMonotonicUnaryFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlMonotonicUnaryFunction.java
@@ -37,9 +37,9 @@ public class SqlMonotonicUnaryFunction extends SqlFunction {
   protected SqlMonotonicUnaryFunction(
       String name,
       SqlKind kind,
-      SqlReturnTypeInference returnTypeInference,
+      @Nullable SqlReturnTypeInference returnTypeInference,
       @Nullable SqlOperandTypeInference operandTypeInference,
-      SqlOperandTypeChecker operandTypeChecker,
+      @Nullable SqlOperandTypeChecker operandTypeChecker,
       SqlFunctionCategory funcType) {
     super(
         name,
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 1eca1e254902..a88f23f29f5c 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
@@ -68,6 +68,7 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.util.ReflectiveSqlOperatorTable;
 import org.apache.calcite.sql.validate.SqlConformance;
+import org.apache.calcite.sql.validate.SqlConformanceEnum;
 import org.apache.calcite.sql.validate.SqlModality;
 import org.apache.calcite.sql2rel.AuxiliaryConverter;
 import org.apache.calcite.util.Litmus;
@@ -1551,6 +1552,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);
         }
@@ -2698,4 +2703,14 @@ public static SqlOperator like(boolean negated, boolean caseSensitive) {
     }
   }
 
+  /** Returns the operator for {@code FLOOR} and {@code CEIL} with given floor flag
+   * and library. */
+  public static SqlOperator floorCeil(boolean floor, SqlConformanceEnum conformance) {
+    switch (conformance) {
+    case BIG_QUERY:
+      return floor ? SqlLibraryOperators.FLOOR_BIG_QUERY : SqlLibraryOperators.CEIL_BIG_QUERY;
+    default:
+      return floor ? SqlStdOperatorTable.FLOOR : SqlStdOperatorTable.CEIL;
+    }
+  }
 }
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 da77594623fb..8ef8d163e990 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.
@@ -511,6 +528,29 @@ public static SqlCall stripSeparator(SqlCall call) {
       opBinding -> opBinding.getTypeFactory().leastRestrictive(
           opBinding.collectOperandTypes());
 
+  /**
+   * Type-inference strategy that returns the type of the first operand, unless it
+   * is an integer type, in which case the return type is DOUBLE.
+   */
+  public static final SqlReturnTypeInference ARG0_EXCEPT_INTEGER = opBinding ->  {
+    RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
+    SqlTypeName op = opBinding.getOperandType(0).getSqlTypeName();
+    if (SqlTypeName.INT_TYPES.contains(op)) {
+      return typeFactory.createTypeWithNullability(
+          typeFactory.createSqlType(SqlTypeName.DOUBLE), true);
+    } else {
+      return typeFactory.createTypeWithNullability(typeFactory.createSqlType(op), true);
+    }
+  };
+
+  /**
+   * Same as {@link #ARG0_EXCEPT_INTEGER} but returns with nullability if any of
+   * the operands is nullable by using
+   * {@link org.apache.calcite.sql.type.SqlTypeTransforms#TO_NULLABLE}.
+   */
+  public static final SqlReturnTypeInference ARG0_EXCEPT_INTEGER_NULLABLE =
+      ARG0_EXCEPT_INTEGER.andThen(SqlTypeTransforms.TO_NULLABLE);
+
   /**
    * Returns the same type as the multiset carries. The multiset type returned
    * is the least restrictive of the call's multiset operands
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 b8501f02f14a..c4c32a48b1a8 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.
+   *
+   * 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/sql2rel/StandardConvertletTable.java b/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
index e416f6abbdc7..64da30db3a11 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;
 
@@ -196,26 +197,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 1ca3a41fb63e..76ce23d0c6b3 100644
--- a/core/src/main/java/org/apache/calcite/util/Bug.java
+++ b/core/src/main/java/org/apache/calcite/util/Bug.java
@@ -173,6 +173,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 4e50e002f8e6..3d3b01d61385 100644
--- a/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
+++ b/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
@@ -545,6 +545,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 205a0fdfd9d4..0bde595e0d2b 100644
--- a/core/src/main/java/org/apache/calcite/util/Sources.java
+++ b/core/src/main/java/org/apache/calcite/util/Sources.java
@@ -189,22 +189,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/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java b/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java
index 752fa12f25c7..af9348ea8b11 100644
--- a/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java
+++ b/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java
@@ -49,12 +49,37 @@ public TimestampWithTimeZoneString(TimestampString localDateTime, TimeZone timeZ
     this.v = localDateTime.toString() + " " + timeZone.getID();
   }
 
-  /** Creates a TimestampWithTimeZoneString. */
+  /** Creates a TimestampWithTimeZoneString.
+   *
+   * TODO: BigQuery allows odd TIMESTAMP literals that, with proper aliasing of
+   * TIMESTAMP -> TIMESTAMP WITH LOCAL TIME ZONE, cause failures here.
+   * There are two cases this band-aid patch addresses:
+   *   1) A `TIMESTAMP` with a date format in function calls
+   *        e.g. TIMESTAMP_DIFF(TIMESTAMP "2018-08-14", TIMESTAMP "2018-10-14", DAY)
+   *   2) TIMESTAMP literals without a provided timezone e.g. TIMESTAMP "2010-07-07 10:20:00"
+   *
+   * Both cases were throwing an {@link IndexOutOfBoundsException} when evaluating the
+   * `timeZoneString` of a literal.
+   * */
+  private static final int TIMESTAMP_WITH_TIMEZONE_LENGTH = 20;
+  private static final int DATE_LENGTH = 10;
+
   public TimestampWithTimeZoneString(String v) {
-    this.localDateTime = new TimestampString(v.substring(0, v.indexOf(' ', 11)));
-    String timeZoneString = v.substring(v.indexOf(' ', 11) + 1);
-    Preconditions.checkArgument(DateTimeStringUtils.isValidTimeZone(timeZoneString));
-    this.timeZone = TimeZone.getTimeZone(timeZoneString);
+    if (v.length() < TIMESTAMP_WITH_TIMEZONE_LENGTH) {
+      if (v.length() == DATE_LENGTH) {
+        // pad a date format string to a timestamp
+        this.localDateTime = new TimestampString(v + " 00:00:00");
+      } else {
+        this.localDateTime = new TimestampString(v);
+      }
+      // if there is no TZ info pretend we are BigQuery and set it as UTC.
+      this.timeZone = TimeZone.getTimeZone("UTC");
+    } else {
+      this.localDateTime = new TimestampString(v.substring(0, v.indexOf(' ', DATE_LENGTH + 1)));
+      String timeZoneString = v.substring(v.indexOf(' ', DATE_LENGTH + 1) + 1);
+      Preconditions.checkArgument(DateTimeStringUtils.isValidTimeZone(timeZoneString));
+      this.timeZone = TimeZone.getTimeZone(timeZoneString);
+    }
     this.v = v;
   }
 
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 8415fcedc0c1..ba0521f2c2f2 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
@@ -661,7 +661,7 @@ public static class LocalServiceMoreFactory implements Service.Factory {
       try {
         Connection conn = makeConnection();
         final CalciteMetaImpl meta =
-            new CalciteMetaImpl(conn.unwrap(CalciteConnectionImpl.class));
+            new CalciteMetaImpl(conn.unwrap(CalciteConnectionImpl.class), null, null);
         return new LocalService(meta);
       } catch (Exception e) {
         throw TestUtil.rethrow(e);
@@ -818,7 +818,7 @@ public static class Factory implements Meta.Factory {
     public Meta create(List<String> args) {
       try {
         final Connection connection = CalciteAssert.hr().connect();
-        return new CalciteMetaImpl((CalciteConnectionImpl) connection);
+        return new CalciteMetaImpl((CalciteConnectionImpl) connection, null, null);
       } catch (Exception e) {
         throw TestUtil.rethrow(e);
       }
@@ -846,7 +846,7 @@ public static class LocalServiceModifiableFactory implements Service.Factory {
         Connection conn = JdbcFrontLinqBackTest.makeConnection();
         final CalciteMetaImpl meta =
             new CalciteMetaImpl(
-                conn.unwrap(CalciteConnectionImpl.class));
+                conn.unwrap(CalciteConnectionImpl.class), null, null);
         return new LocalService(meta);
       } catch (Exception e) {
         throw TestUtil.rethrow(e);
diff --git a/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java b/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java
index 8eccd362f6b0..658c0b5657d9 100644
--- a/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java
@@ -134,6 +134,10 @@ class RelWriterTest {
       + "          \"kind\": \"EQUALS\",\n"
       + "          \"syntax\": \"BINARY\"\n"
       + "        },\n"
+      + "        \"type\": {\n"
+      + "          \"type\": \"BOOLEAN\",\n"
+      + "          \"nullable\": false\n"
+      + "        },\n"
       + "        \"operands\": [\n"
       + "          {\n"
       + "            \"input\": 1,\n"
@@ -293,6 +297,10 @@ class RelWriterTest {
       + "            \"kind\": \"COUNT\",\n"
       + "            \"syntax\": \"FUNCTION_STAR\"\n"
       + "          },\n"
+      + "          \"type\": {\n"
+      + "            \"type\": \"BIGINT\",\n"
+      + "            \"nullable\": false\n"
+      + "          },\n"
       + "          \"operands\": [\n"
       + "            {\n"
       + "              \"input\": 0,\n"
@@ -300,10 +308,6 @@ class RelWriterTest {
       + "            }\n"
       + "          ],\n"
       + "          \"distinct\": false,\n"
-      + "          \"type\": {\n"
-      + "            \"type\": \"BIGINT\",\n"
-      + "            \"nullable\": false\n"
-      + "          },\n"
       + "          \"window\": {\n"
       + "            \"partition\": [\n"
       + "              {\n"
@@ -335,6 +339,10 @@ class RelWriterTest {
       + "            \"kind\": \"SUM\",\n"
       + "            \"syntax\": \"FUNCTION\"\n"
       + "          },\n"
+      + "          \"type\": {\n"
+      + "            \"type\": \"BIGINT\",\n"
+      + "            \"nullable\": false\n"
+      + "          },\n"
       + "          \"operands\": [\n"
       + "            {\n"
       + "              \"input\": 0,\n"
@@ -342,10 +350,6 @@ class RelWriterTest {
       + "            }\n"
       + "          ],\n"
       + "          \"distinct\": false,\n"
-      + "          \"type\": {\n"
-      + "            \"type\": \"BIGINT\",\n"
-      + "            \"nullable\": false\n"
-      + "          },\n"
       + "          \"window\": {\n"
       + "            \"partition\": [\n"
       + "              {\n"
@@ -786,7 +790,8 @@ private void assertThatReadExpressionResult(String json, Matcher<String> matcher
       throw TestUtil.rethrow(e);
     }
     final RelJson relJson = RelJson.create()
-        .withInputTranslator(RelWriterTest::translateInput);
+        .withInputTranslator(RelWriterTest::translateInput)
+        .withLibraryOperatorTable();
     final RexNode e = relJson.toRex(cluster, o);
     assertThat(e, hasToString(matcher));
   }
@@ -1052,6 +1057,42 @@ void testAggregateWithAlias(SqlExplainFormat format) {
     assertThat(result, isLinux(expected));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5607">[CALCITE-5607]</a>
+   * <p>Before the fix, RelJson.toRex would throw an ArrayIndexOutOfBounds error
+   * when deserialization.
+   * */
+  @Test void testDeserializeMinusDateOperator() {
+    final FrameworkConfig config = RelBuilderTest.config().build();
+    final RelBuilder builder = RelBuilder.create(config);
+    final RexBuilder rb = builder.getRexBuilder();
+    final RelDataTypeFactory typeFactory = rb.getTypeFactory();
+    final SqlIntervalQualifier qualifier =
+        new SqlIntervalQualifier(TimeUnit.MONTH, null, SqlParserPos.ZERO);
+    final RexNode op1 = rb.makeTimestampLiteral(new TimestampString("2012-12-03 12:34:44"), 0);
+    final RexNode op2 = rb.makeTimestampLiteral(new TimestampString("2014-12-23 12:34:44"), 0);
+    final RelDataType intervalType =
+        typeFactory.createTypeWithNullability(
+            typeFactory.createSqlIntervalType(qualifier),
+            op1.getType().isNullable() || op2.getType().isNullable());
+    final RelNode rel = builder
+        .scan("EMP")
+        .project(builder.field("JOB"),
+            rb.makeCall(intervalType,
+                SqlStdOperatorTable.MINUS_DATE,
+                ImmutableList.of(op2, op1)))
+        .build();
+    final RelJsonWriter jsonWriter =
+        new RelJsonWriter(new JsonBuilder(), RelJson::withLibraryOperatorTable);
+    rel.explain(jsonWriter);
+    String relJson = jsonWriter.asString();
+    String result = deserializeAndDumpToTextFormat(getSchema(rel), relJson);
+    final String expected =
+        "LogicalProject(JOB=[$2], $f1=[-(2014-12-23 12:34:44, 2012-12-03 12:34:44)])\n"
+        + "  LogicalTableScan(table=[[scott, EMP]])\n";
+    assertThat(result, isLinux(expected));
+  }
+
   @Test void testAggregateWithoutAlias() {
     final FrameworkConfig config = RelBuilderTest.config().build();
     final RelBuilder builder = RelBuilder.create(config);
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 3eafff29d654..01de3b2a52b8 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
@@ -54,6 +54,7 @@
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.SqlWriterConfig;
 import org.apache.calcite.sql.dialect.AnsiSqlDialect;
+import org.apache.calcite.sql.dialect.BigQuerySqlDialect;
 import org.apache.calcite.sql.dialect.CalciteSqlDialect;
 import org.apache.calcite.sql.dialect.HiveSqlDialect;
 import org.apache.calcite.sql.dialect.JethroDataSqlDialect;
@@ -490,6 +491,30 @@ private static String toSql(RelNode root, SqlDialect dialect,
         .withPresto().ok(expected);
   }
 
+  /** When ceiling/flooring an integer, BigQuery returns a double while Calcite and other dialects
+   * return an integer. Therefore, casts to integer types should be preserved for BigQuery. */
+  @Test void testBigQueryCeilPreservesCast() {
+    final String query = "SELECT TIMESTAMP_SECONDS(CAST(CEIL(CAST(3 AS BIGINT)) AS BIGINT)) "
+        + "as created_thing\n FROM `foodmart`.`product`";
+    final SqlParser.Config parserConfig =
+        BigQuerySqlDialect.DEFAULT.configureParser(SqlParser.config());
+    final Sql sql = fixture()
+        .withBigQuery().withLibrary(SqlLibrary.BIG_QUERY).parserConfig(parserConfig);
+    sql.withSql(query).ok("SELECT TIMESTAMP_SECONDS(CAST(CEIL(3) AS INT64)) AS "
+        + "created_thing\nFROM foodmart.product");
+  }
+
+  @Test void testBigQueryFloorPreservesCast() {
+    final String query = "SELECT TIMESTAMP_SECONDS(CAST(FLOOR(CAST(3 AS BIGINT)) AS BIGINT)) "
+        + "as created_thing\n FROM `foodmart`.`product`";
+    final SqlParser.Config parserConfig =
+        BigQuerySqlDialect.DEFAULT.configureParser(SqlParser.config());
+    final Sql sql = fixture()
+        .withBigQuery().withLibrary(SqlLibrary.BIG_QUERY).parserConfig(parserConfig);
+    sql.withSql(query).ok("SELECT TIMESTAMP_SECONDS(CAST(FLOOR(3) AS INT64)) AS "
+        + "created_thing\nFROM foodmart.product");
+  }
+
   @Test void testSelectLiteralAgg() {
     final Function<RelBuilder, RelNode> relFn = b -> b
         .scan("EMP")
@@ -1912,8 +1937,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"
@@ -2077,6 +2103,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";
@@ -3155,7 +3208,7 @@ private SqlDialect nonOrdinalDialect() {
     // BigQuery uses LIMIT/OFFSET, and nulls sort low by default
     final String expectedBigQuery = "SELECT product_id\n"
         + "FROM foodmart.product\n"
-        + "ORDER BY net_weight IS NULL, net_weight\n"
+        + "ORDER BY net_weight NULLS LAST\n"
         + "LIMIT 100\n"
         + "OFFSET 10";
     sql(query).ok(expected)
@@ -7049,7 +7102,7 @@ private void checkLiteral2(String expression, String expected) {
         + "FROM SCOTT.EMP\n"
         + "GROUP BY DEPTNO\n"
         + "HAVING COUNT(DISTINCT EMPNO) > 0\n"
-        + "ORDER BY COUNT(DISTINCT EMPNO) IS NULL DESC, 2 DESC";
+        + "ORDER BY 2 DESC NULLS FIRST";
 
     // Convert rel node to SQL with BigQuery dialect,
     // in which "isHavingAlias" is true.
diff --git a/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java b/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java
index 4bb84046b6fb..98da8058ebaf 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java
@@ -16,6 +16,9 @@
  */
 package org.apache.calcite.test;
 
+import org.apache.calcite.config.CalciteConnectionProperty;
+import org.apache.calcite.jdbc.CalciteMetaImpl.CalciteMetaTable;
+import org.apache.calcite.schema.Table;
 import org.apache.calcite.util.TestUtil;
 
 import org.hamcrest.Matcher;
@@ -24,6 +27,8 @@
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Map;
 
 import static org.apache.calcite.test.CalciteAssert.that;
 
@@ -32,6 +37,7 @@
 import static org.hamcrest.Matchers.hasToString;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Tests for a JDBC front-end and JDBC back-end.
@@ -73,6 +79,55 @@ class JdbcFrontJdbcBackTest {
         });
   }
 
+
+  /** Sample subclass testing getMetaTables. */
+  public static class MetaExtraTable extends CalciteMetaTable {
+    public final String extraLabel;
+
+    // Got a RedundantModifier alert, however CalciteMetaImpl does need this constructor to be
+    // explicitly public in order to create an instance.
+    // CHECKSTYLE: IGNORE 2
+    public MetaExtraTable(Table calciteTable, String tableCat,
+        String tableSchem, String tableName) {
+      super(calciteTable, tableCat, tableSchem, tableName);
+      Map<String, Object> metadataMap = calciteTable.getTableMetadata();
+      Object extraLabel1 = metadataMap.getOrDefault("extraLabel", null);
+      this.extraLabel = extraLabel1 != null ? (String) extraLabel1 : null;
+    }
+    public static String[] getColumnNames() {
+      return Arrays.asList("TABLE_CAT",
+          "TABLE_SCHEM",
+          "TABLE_NAME",
+          "TABLE_TYPE",
+          "REMARKS",
+          "TYPE_CAT",
+          "TYPE_SCHEM",
+          "TYPE_NAME",
+          "SELF_REFERENCING_COL_NAME",
+          "REF_GENERATION",
+          "EXTRA_LABEL").toArray(new String[0]);
+    }
+  }
+  @Test void testTablesExtraColumn() throws Exception {
+    that()
+        .with(CalciteAssert.Config.JDBC_FOODMART)
+        .with(
+            CalciteConnectionProperty.META_TABLE_CLASS.camelName(), MetaExtraTable.class.getName())
+        .doWithConnection(connection -> {
+          try {
+            ResultSet rset =
+                connection.getMetaData().getTables(
+                    null, null, null, null);
+            assertTrue(rset.next());
+            assertEquals(rset.getMetaData().getColumnCount(), 11);
+            assertEquals(rset.getMetaData().getColumnName(11), "EXTRA_LABEL");
+          } catch (SQLException e) {
+            throw TestUtil.rethrow(e);
+          }
+        });
+
+  }
+
   @Test void testTablesByType() throws Exception {
     // check with the form recommended by JDBC
     checkTablesByType("SYSTEM TABLE", is("COLUMNS;TABLES;"));
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 2367c88699dd..17b6eed03780 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
@@ -5916,11 +5916,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/UdtTest.java b/core/src/test/java/org/apache/calcite/test/UdtTest.java
index 970a40a0b785..84fb63175ce5 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,16 @@ 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 730766d8d5c5..36e991f250e7 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/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/PredicateAnalyzer.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/PredicateAnalyzer.java
index 95d829f4d562..aa94927d2574 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;
@@ -170,6 +171,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()) {
@@ -186,13 +196,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:
@@ -246,8 +249,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:
@@ -265,6 +266,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 a1a7801255a3..e5b27ad28662 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -29,7 +29,7 @@ systemProp.org.gradle.internal.publish.checksums.insecure=true
 # Release version can be generated by using -Prelease or -Prc=<int> arguments
 calcite.version=1.35.0
 # This is a version to be used from Maven repository. It can be overridden by localAvatica below
-calcite.avatica.version=1.23.0
+calcite.avatica.version=1.23.3-looker-SNAPSHOT
 
 # The options below configures the use of local clone (e.g. testing development versions)
 # You can pass un-comment it, or pass option -PlocalReleasePlugins, or -PlocalReleasePlugins=<path>
@@ -37,7 +37,7 @@ calcite.avatica.version=1.23.0
 # localAvatica=../calcite-avatica
 
 # By default, Maven Local repository is not used
-# enableMavenLocal=true
+enableMavenLocal=true
 # Gradle metadata is not well supported in the build script, so it is disabled for now
 # publishGradleMetadata=true
 
diff --git a/looker.md b/looker.md
new file mode 100644
index 000000000000..c5a7a62f640f
--- /dev/null
+++ b/looker.md
@@ -0,0 +1,113 @@
+<!--
+{% 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
+
+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 `./upload-looker-snapshot.sh`,
+which runs `./gradlew build` and,
+if successful, uploads the resulting artifacts to the repo
+using the version number configured in `gradle.properties` (plus a "-SNAPSHOT" suffix).
+
+Then, update the version in Looker's `internal/repositories/maven_deps.bzl` and repin,
+and you're ready to build.
+
+## Release
+
+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.
+
+In Calcite's `gradle.properties`, update the value of
+`calcite.version` to the release name (something like
+`1.22.1-looker`) and commit.
+
+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.
+
+Publish:
+```sh
+./gradlew -Prelease -PskipSign publishAllPublicationsToLookerNexusRepository
+```
+
+Check the artifacts
+[on Nexus](https://nexusproxy.looker.com/#browse/search=keyword%3Dorg.apache.calcite).
+
+If the release was successful, tag the release and push the tag:
+```sh
+git tag calcite-1.21.1-looker HEAD
+git push julianhyde calcite-1.21.1-looker
+```
diff --git a/release-helper.sh b/release-helper.sh
new file mode 100755
index 000000000000..30f6bc051ceb
--- /dev/null
+++ b/release-helper.sh
@@ -0,0 +1,66 @@
+#!/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
+# 2. Do whatever needs to be done (rebase on trunk, cherry-pick, remove fixups, etc.).
+# 3. Once the code looks good and your Git working directory is clean, run this script, which will:
+#    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.
+#       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
+  sed -i "/^calcite\\.version=.*/c\\calcite.version=$NEXT_VERSION" gradle.properties
+
+  echo -e "\nBuilding '$NEXT_VERSION'..." >&2
+  ./gradlew build -x :redis:test && (
+
+    echo -e "\nTests passed! Setting local looker branch." >&2
+    git branch -f looker
+
+    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.\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 force-push the looker branch and release tag to looker-open-source with this command:\n" >&2
+      echo -e "    git push -f git@github.com:looker-open-source/calcite.git looker $NEXT_TAG"
+    )
+  )
+)
diff --git a/site/_docs/reference.md b/site/_docs/reference.md
index 351cbb8b23fd..f6aabaef0b57 100644
--- a/site/_docs/reference.md
+++ b/site/_docs/reference.md
@@ -2673,6 +2673,7 @@ BigQuery's type system uses confusingly different names for types and functions:
 | s | SORT_ARRAY(array [, ascendingOrder])           | Sorts the *array* in ascending or descending order according to the natural ordering of the array elements. The default order is ascending if *ascendingOrder* is not specified. Null elements will be placed at the beginning of the returned array in ascending order or at the end of the returned array in descending order
 | * | ASINH(numeric)                                 | Returns the inverse hyperbolic sine of *numeric*
 | * | ATANH(numeric)                                 | Returns the inverse hyperbolic tangent of *numeric*
+| b | CEIL(value)                                    | Similar to standard `CEIL(value)` except if *value* is an integer type, the return type is a double
 | m s | CHAR(integer)                                | Returns the character whose ASCII code is *integer* % 256, or null if *integer* &lt; 0
 | b o p | CHR(integer)                               | Returns the character whose UTF-8 code is *integer*
 | o | CONCAT(string, string)                         | Concatenates two strings, returns null only when both string arguments are null, otherwise treats null as empty string
@@ -2715,6 +2716,7 @@ BigQuery's type system uses confusingly different names for types and functions:
 | o | EXTRACT(xml, xpath, [, namespaces ])           | Returns the XML fragment of the element or elements matched by the XPath expression. The optional namespace value that specifies a default mapping or namespace mapping for prefixes, which is used when evaluating the XPath expression
 | o | EXISTSNODE(xml, xpath, [, namespaces ])        | Determines whether traversal of a XML document using a specified xpath results in any nodes. Returns 0 if no nodes remain after applying the XPath traversal on the document fragment of the element or elements matched by the XPath expression. Returns 1 if any nodes remain. The optional namespace value that specifies a default mapping or namespace mapping for prefixes, which is used when evaluating the XPath expression.
 | m | EXTRACTVALUE(xml, xpathExpr))                  | Returns the text of the first text node which is a child of the element or elements matched by the XPath expression.
+| b | FLOOR(value)                                   | Similar to standard `FLOOR(value)` except if *value* is an integer type, the return type is a double
 | b | FORMAT_DATE(string, date)                      | Formats *date* according to the specified format *string*
 | b | FORMAT_DATETIME(string, timestamp)             | Formats *timestamp* according to the specified format *string*
 | b | FORMAT_TIME(string, time)                      | Formats *time* according to the specified format *string*
diff --git a/src/main/config/checkerframework/avatica/MetaImpl.astub b/src/main/config/checkerframework/avatica/MetaImpl.astub
index 501f29b01228..d7a9c9a1f0b8 100644
--- a/src/main/config/checkerframework/avatica/MetaImpl.astub
+++ b/src/main/config/checkerframework/avatica/MetaImpl.astub
@@ -41,7 +41,9 @@ class MetaImpl {
       int nullable,
       Integer charOctetLength,
       int ordinalPosition,
-      String isNullable);
+      String isNullable,
+      String isAutoincrement,
+      String isGeneratedcolumn);
   }
 
   class MetaTypeInfo {
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 d78fab432494..5623e0f3a9f2 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
@@ -8594,15 +8594,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 42af61dac30e..ceb7a2f82767 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;
@@ -899,6 +902,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;
@@ -927,7 +933,16 @@ 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(".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(".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 77d9734afe9b..ee0a25702f3a 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
@@ -8246,13 +8246,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')",
@@ -8699,6 +8716,38 @@ private static void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     f.checkNull("floor(cast(null as real))");
   }
 
+  @Test void testBigQueryCeilFunc() {
+    final SqlOperatorFixture f0 = fixture();
+    f0.checkType("ceil(cast(3 as tinyint))", "TINYINT NOT NULL");
+    final SqlOperatorFixture f = f0.setFor(SqlLibraryOperators.FLOOR_BIG_QUERY)
+        .withLibrary(SqlLibrary.BIG_QUERY).withConformance(SqlConformanceEnum.BIG_QUERY);
+    f.checkScalarExact("ceil(cast(3 as tinyint))", "DOUBLE", "3.0");
+    f.checkScalarExact("ceil(cast(3 as smallint))", "DOUBLE", "3.0");
+    f.checkScalarExact("ceil(cast(3 as integer))", "DOUBLE", "3.0");
+    f.checkScalarExact("ceil(cast(3 as bigint))", "DOUBLE", "3.0");
+    f.checkScalarExact("ceil(cast(3.5 as double))", "DOUBLE", "4.0");
+    f.checkScalarExact("ceil(cast(3.45 as decimal))",
+        "DECIMAL(19, 0)", "4");
+    f.checkScalarExact("ceil(cast(3.45 as float))", "FLOAT", "4.0");
+    f.checkNull("ceil(cast(null as tinyint))");
+  }
+
+  @Test void testBigQueryFloorFunc() {
+    final SqlOperatorFixture f0 = fixture();
+    f0.checkType("floor(cast(3 as tinyint))", "TINYINT NOT NULL");
+    final SqlOperatorFixture f = f0.setFor(SqlLibraryOperators.FLOOR_BIG_QUERY)
+        .withLibrary(SqlLibrary.BIG_QUERY).withConformance(SqlConformanceEnum.BIG_QUERY);
+    f.checkScalarExact("floor(cast(3 as tinyint))", "DOUBLE", "3.0");
+    f.checkScalarExact("floor(cast(3 as smallint))", "DOUBLE", "3.0");
+    f.checkScalarExact("floor(cast(3 as integer))", "DOUBLE", "3.0");
+    f.checkScalarExact("floor(cast(3 as bigint))", "DOUBLE", "3.0");
+    f.checkScalarExact("floor(cast(3.5 as double))", "DOUBLE", "3.0");
+    f.checkScalarExact("floor(cast(3.45 as decimal))",
+        "DECIMAL(19, 0)", "3");
+    f.checkScalarExact("floor(cast(3.45 as float))", "FLOAT", "3.0");
+    f.checkNull("floor(cast(null as tinyint))");
+  }
+
   @Test void testFloorFuncDateTime() {
     final SqlOperatorFixture f = fixture();
     f.enableTypeCoercion(false)
@@ -8864,11 +8913,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() {
@@ -9180,102 +9231,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)}
@@ -9296,102 +9349,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})
@@ -9400,121 +9456,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() {
@@ -9737,37 +9796,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() {
@@ -10122,6 +10182,7 @@ void testTimestampDiff(boolean coercionEnabled) {
   @Test void testParseTimestamp() {
     final SqlOperatorFixture f = fixture()
         .withLibrary(SqlLibrary.BIG_QUERY)
+        .withConnectionFactory(cf -> cf.with(CalciteConnectionProperty.TIME_ZONE, "UTC"))
         .setFor(SqlLibraryOperators.PARSE_TIMESTAMP);
     f.checkScalar("PARSE_TIMESTAMP('%a %b %e %I:%M:%S %Y', 'Thu Dec 25 07:30:00 2008')",
         "2008-12-25 07:30:00",
@@ -10129,8 +10190,19 @@ void testTimestampDiff(boolean coercionEnabled) {
     f.checkScalar("PARSE_TIMESTAMP('%c', 'Thu Dec 25 07:30:00 2008')",
         "2008-12-25 07:30:00",
         "TIMESTAMP_WITH_LOCAL_TIME_ZONE(0) NOT NULL");
+  }
+
+  @Test void testParseTimestampInAlternateTimeZone() {
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .withConnectionFactory(
+            cf -> cf.with(CalciteConnectionProperty.TIME_ZONE, "America/Los_Angeles"))
+        .setFor(SqlLibraryOperators.PARSE_TIMESTAMP);
+    f.checkScalar("PARSE_TIMESTAMP('%a %b %e %I:%M:%S %Y', 'Thu Dec 25 07:30:00 2008')",
+        "2008-12-24 23:30:00",
+        "TIMESTAMP_WITH_LOCAL_TIME_ZONE(0) NOT NULL");
     f.checkScalar("PARSE_TIMESTAMP('%c', 'Thu Dec 25 07:30:00 2008')",
-        "2008-12-25 07:30:00",
+        "2008-12-24 23:30:00",
         "TIMESTAMP_WITH_LOCAL_TIME_ZONE(0) NOT NULL");
   }
 
diff --git a/upload-looker-snapshot.sh b/upload-looker-snapshot.sh
new file mode 100755
index 000000000000..ac49a3d093a4
--- /dev/null
+++ b/upload-looker-snapshot.sh
@@ -0,0 +1,42 @@
+#!/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 artifact ID
+# $2 is the version
+# $3 is the JAR path
+function snapshot_upload {
+    mvn deploy:deploy-file \
+        -DgroupId=org.apache.calcite \
+        -DartifactId="$1" \
+        -Dversion="$2" \
+        -Dpackaging=jar \
+        -Dfile="$3" \
+        -DgeneratePom=true \
+        -DrepositoryId=nexus \
+        -Durl=https://nexusrepo.looker.com/repository/maven-snapshots/
+}
+
+./gradlew build && (
+    VERSION="$(sed -n 's/^calcite\.version=\([^ ]*\).*/\1/p' gradle.properties)-SNAPSHOT"
+    snapshot_upload calcite-core "$VERSION" "./core/build/libs/calcite-core-$VERSION.jar"
+    snapshot_upload calcite-babel "$VERSION" "./babel/build/libs/calcite-babel-$VERSION.jar"
+    snapshot_upload calcite-linq4j "$VERSION" "./linq4j/build/libs/calcite-linq4j-$VERSION.jar"
+    snapshot_upload calcite-testkit "$VERSION" "./testkit/build/libs/calcite-testkit-$VERSION.jar"
+    echo
+    echo "Done uploading version ${VERSION} to Looker Nexus Snapshots!"
+)